]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix for bug [ 1351659 ] wxTextValidator::Validate not Unicode safe
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1343 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1344 #define SWIGTYPE_p_wxEventLoopActivator swig_types[2]
1345 #define SWIGTYPE_p_wxSizerItem swig_types[3]
1346 #define SWIGTYPE_p_wxGBSizerItem swig_types[4]
1347 #define SWIGTYPE_p_wxScrollEvent swig_types[5]
1348 #define SWIGTYPE_p_wxEventLoop swig_types[6]
1349 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[7]
1350 #define SWIGTYPE_p_wxSizer swig_types[8]
1351 #define SWIGTYPE_p_wxBoxSizer swig_types[9]
1352 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[10]
1353 #define SWIGTYPE_p_wxGridBagSizer swig_types[11]
1354 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[12]
1355 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[13]
1356 #define SWIGTYPE_p_wxEvent swig_types[14]
1357 #define SWIGTYPE_p_buffer swig_types[15]
1358 #define SWIGTYPE_p_wxMenu swig_types[16]
1359 #define SWIGTYPE_p_wxGridSizer swig_types[17]
1360 #define SWIGTYPE_p_wxFlexGridSizer swig_types[18]
1361 #define SWIGTYPE_p_wxInitDialogEvent swig_types[19]
1362 #define SWIGTYPE_p_wxItemContainer swig_types[20]
1363 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1364 #define SWIGTYPE_p_wxNcPaintEvent swig_types[22]
1365 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[23]
1366 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[24]
1367 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[25]
1368 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[26]
1369 #define SWIGTYPE_p_wxControl swig_types[27]
1370 #define SWIGTYPE_p_wxFont swig_types[28]
1371 #define SWIGTYPE_p_wxMenuBarBase swig_types[29]
1372 #define SWIGTYPE_p_wxSetCursorEvent swig_types[30]
1373 #define SWIGTYPE_p_wxFSFile swig_types[31]
1374 #define SWIGTYPE_p_wxCaret swig_types[32]
1375 #define SWIGTYPE_ptrdiff_t swig_types[33]
1376 #define SWIGTYPE_std__ptrdiff_t swig_types[34]
1377 #define SWIGTYPE_p_wxRegion swig_types[35]
1378 #define SWIGTYPE_p_wxPoint2D swig_types[36]
1379 #define SWIGTYPE_p_wxImage_HSVValue swig_types[37]
1380 #define SWIGTYPE_p_int swig_types[38]
1381 #define SWIGTYPE_p_wxSize swig_types[39]
1382 #define SWIGTYPE_p_wxDC swig_types[40]
1383 #define SWIGTYPE_p_wxPySizer swig_types[41]
1384 #define SWIGTYPE_p_wxVisualAttributes swig_types[42]
1385 #define SWIGTYPE_p_wxImage_RGBValue swig_types[43]
1386 #define SWIGTYPE_p_wxNotifyEvent swig_types[44]
1387 #define SWIGTYPE_p_wxPyEvent swig_types[45]
1388 #define SWIGTYPE_p_wxPropagationDisabler swig_types[46]
1389 #define SWIGTYPE_p_form_ops_t swig_types[47]
1390 #define SWIGTYPE_p_wxAppTraits swig_types[48]
1391 #define SWIGTYPE_p_wxArrayString swig_types[49]
1392 #define SWIGTYPE_p_wxShowEvent swig_types[50]
1393 #define SWIGTYPE_p_wxToolTip swig_types[51]
1394 #define SWIGTYPE_p_wxMoveEvent swig_types[52]
1395 #define SWIGTYPE_p_wxSizeEvent swig_types[53]
1396 #define SWIGTYPE_p_wxActivateEvent swig_types[54]
1397 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
1398 #define SWIGTYPE_p_wxMaximizeEvent swig_types[56]
1399 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[57]
1400 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[58]
1401 #define SWIGTYPE_p_wxIdleEvent swig_types[59]
1402 #define SWIGTYPE_p_wxDateEvent swig_types[60]
1403 #define SWIGTYPE_p_wxMenuItem swig_types[61]
1404 #define SWIGTYPE_p_wxStaticBox swig_types[62]
1405 #define SWIGTYPE_p_long swig_types[63]
1406 #define SWIGTYPE_p_wxDuplexMode swig_types[64]
1407 #define SWIGTYPE_p_wxTIFFHandler swig_types[65]
1408 #define SWIGTYPE_p_wxXPMHandler swig_types[66]
1409 #define SWIGTYPE_p_wxPNMHandler swig_types[67]
1410 #define SWIGTYPE_p_wxJPEGHandler swig_types[68]
1411 #define SWIGTYPE_p_wxPCXHandler swig_types[69]
1412 #define SWIGTYPE_p_wxGIFHandler swig_types[70]
1413 #define SWIGTYPE_p_wxPNGHandler swig_types[71]
1414 #define SWIGTYPE_p_wxANIHandler swig_types[72]
1415 #define SWIGTYPE_p_wxPyImageHandler swig_types[73]
1416 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[74]
1417 #define SWIGTYPE_p_wxZipFSHandler swig_types[75]
1418 #define SWIGTYPE_p_wxInternetFSHandler swig_types[76]
1419 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[77]
1420 #define SWIGTYPE_p_wxEvtHandler swig_types[78]
1421 #define SWIGTYPE_p_wxCURHandler swig_types[79]
1422 #define SWIGTYPE_p_wxICOHandler swig_types[80]
1423 #define SWIGTYPE_p_wxBMPHandler swig_types[81]
1424 #define SWIGTYPE_p_wxImageHandler swig_types[82]
1425 #define SWIGTYPE_p_wxFileSystemHandler swig_types[83]
1426 #define SWIGTYPE_p_wxRect swig_types[84]
1427 #define SWIGTYPE_p_wxButton swig_types[85]
1428 #define SWIGTYPE_p_wxGBSpan swig_types[86]
1429 #define SWIGTYPE_p_wxPropagateOnce swig_types[87]
1430 #define SWIGTYPE_p_wxAcceleratorTable swig_types[88]
1431 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[89]
1432 #define SWIGTYPE_p_char swig_types[90]
1433 #define SWIGTYPE_p_wxGBPosition swig_types[91]
1434 #define SWIGTYPE_p_wxImage swig_types[92]
1435 #define SWIGTYPE_p_wxFrame swig_types[93]
1436 #define SWIGTYPE_p_wxScrollWinEvent swig_types[94]
1437 #define SWIGTYPE_p_wxPaperSize swig_types[95]
1438 #define SWIGTYPE_p_wxImageHistogram swig_types[96]
1439 #define SWIGTYPE_p_wxPoint swig_types[97]
1440 #define SWIGTYPE_p_wxCursor swig_types[98]
1441 #define SWIGTYPE_p_wxObject swig_types[99]
1442 #define SWIGTYPE_p_wxInputStream swig_types[100]
1443 #define SWIGTYPE_p_wxOutputStream swig_types[101]
1444 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
1445 #define SWIGTYPE_p_wxDateTime swig_types[103]
1446 #define SWIGTYPE_p_wxKeyEvent swig_types[104]
1447 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[105]
1448 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[106]
1449 #define SWIGTYPE_p_unsigned_long swig_types[107]
1450 #define SWIGTYPE_p_wxWindow swig_types[108]
1451 #define SWIGTYPE_p_wxMenuBar swig_types[109]
1452 #define SWIGTYPE_p_wxFileSystem swig_types[110]
1453 #define SWIGTYPE_p_wxBitmap swig_types[111]
1454 #define SWIGTYPE_unsigned_int swig_types[112]
1455 #define SWIGTYPE_p_unsigned_int swig_types[113]
1456 #define SWIGTYPE_p_wxMenuEvent swig_types[114]
1457 #define SWIGTYPE_p_wxContextMenuEvent swig_types[115]
1458 #define SWIGTYPE_p_unsigned_char swig_types[116]
1459 #define SWIGTYPE_p_wxMouseEvent swig_types[117]
1460 #define SWIGTYPE_p_wxEraseEvent swig_types[118]
1461 #define SWIGTYPE_p_wxCloseEvent swig_types[119]
1462 #define SWIGTYPE_p_wxPyApp swig_types[120]
1463 #define SWIGTYPE_p_wxCommandEvent swig_types[121]
1464 #define SWIGTYPE_p_wxPyCommandEvent swig_types[122]
1465 #define SWIGTYPE_p_wxPyDropTarget swig_types[123]
1466 #define SWIGTYPE_p_wxQuantize swig_types[124]
1467 #define SWIGTYPE_p_wxFocusEvent swig_types[125]
1468 #define SWIGTYPE_p_wxChildFocusEvent swig_types[126]
1469 #define SWIGTYPE_p_wxDropFilesEvent swig_types[127]
1470 #define SWIGTYPE_p_wxControlWithItems swig_types[128]
1471 #define SWIGTYPE_p_wxColour swig_types[129]
1472 #define SWIGTYPE_p_wxValidator swig_types[130]
1473 #define SWIGTYPE_p_wxPyValidator swig_types[131]
1474 static swig_type_info *swig_types[133];
1475
1476 /* -------- TYPES TABLE (END) -------- */
1477
1478
1479 /*-----------------------------------------------
1480 @(target):= _core_.so
1481 ------------------------------------------------*/
1482 #define SWIG_init init_core_
1483
1484 #define SWIG_name "_core_"
1485
1486 #include "wx/wxPython/wxPython_int.h"
1487 #include "wx/wxPython/pyclasses.h"
1488
1489
1490 #ifndef wxPyUSE_EXPORT
1491 // Helper functions for dealing with SWIG objects and such. These are
1492 // located here so they know about the SWIG types and functions declared
1493 // in the wrapper code.
1494
1495 #include <wx/hashmap.h>
1496 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1497
1498
1499 // Maintains a hashmap of className to swig_type_info pointers. Given the
1500 // name of a class either looks up the type info in the cache, or scans the
1501 // SWIG tables for it.
1502 extern PyObject* wxPyPtrTypeMap;
1503 static
1504 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1505
1506 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1507
1508 if (typeInfoCache == NULL)
1509 typeInfoCache = new wxPyTypeInfoHashMap;
1510
1511 wxString name(className);
1512 swig_type_info* swigType = (*typeInfoCache)[name];
1513
1514 if (! swigType) {
1515 // it wasn't in the cache, so look it up from SWIG
1516 name.Append(wxT(" *"));
1517 swigType = SWIG_TypeQuery(name.mb_str());
1518
1519 // if it still wasn't found, try looking for a mapped name
1520 if (!swigType) {
1521 PyObject* item;
1522 name = className;
1523
1524 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1525 (char*)(const char*)name.mbc_str())) != NULL) {
1526 name = wxString(PyString_AsString(item), *wxConvCurrent);
1527 name.Append(wxT(" *"));
1528 swigType = SWIG_TypeQuery(name.mb_str());
1529 }
1530 }
1531 if (swigType) {
1532 // and add it to the map if found
1533 (*typeInfoCache)[className] = swigType;
1534 }
1535 }
1536 return swigType;
1537 }
1538
1539
1540 // Check if a class name is a type known to SWIG
1541 bool wxPyCheckSwigType(const wxChar* className) {
1542
1543 swig_type_info* swigType = wxPyFindSwigType(className);
1544 return swigType != NULL;
1545 }
1546
1547
1548 // Given a pointer to a C++ object and a class name, construct a Python proxy
1549 // object for it.
1550 PyObject* wxPyConstructObject(void* ptr,
1551 const wxChar* className,
1552 int setThisOwn) {
1553
1554 swig_type_info* swigType = wxPyFindSwigType(className);
1555 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1556
1557 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1558 }
1559
1560
1561 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1562 // Ensures that the proxy object is of the specified (or derived) type. If
1563 // not able to perform the conversion then a Python exception is set and the
1564 // error should be handled properly in the caller. Returns True on success.
1565 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1566 const wxChar* className) {
1567
1568 swig_type_info* swigType = wxPyFindSwigType(className);
1569 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1570
1571 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1572 }
1573
1574
1575 // Make a SWIGified pointer object suitable for a .this attribute
1576 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1577
1578 PyObject* robj = NULL;
1579
1580 swig_type_info* swigType = wxPyFindSwigType(className);
1581 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1582
1583 #ifdef SWIG_COBJECT_TYPES
1584 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1585 #else
1586 {
1587 char result[1024];
1588 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1589 PyString_FromString(result) : 0;
1590 }
1591 #endif
1592
1593 return robj;
1594 }
1595
1596
1597 // Python's PyInstance_Check does not return True for instances of new-style
1598 // classes. This should get close enough for both new and old classes but I
1599 // should re-evaluate the need for doing instance checks...
1600 bool wxPyInstance_Check(PyObject* obj) {
1601 return PyObject_HasAttrString(obj, "__class__") != 0;
1602 }
1603
1604
1605
1606 // This one checks if the object is an instance of a SWIG proxy class (it has
1607 // a .this attribute, and the .this attribute is a PySwigObject.)
1608 bool wxPySwigInstance_Check(PyObject* obj) {
1609 static PyObject* this_str = NULL;
1610 if (this_str == NULL)
1611 this_str = PyString_FromString("this");
1612
1613 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
1614 if (this_attr) {
1615 bool retval = (PySwigObject_Check(this_attr) != 0);
1616 Py_DECREF(this_attr);
1617 return retval;
1618 }
1619
1620 PyErr_Clear();
1621 return false;
1622 }
1623
1624
1625
1626 // Export a C API in a struct. Other modules will be able to load this from
1627 // the wx._core_ module and will then have safe access to these functions,
1628 // even if they are located in another shared library.
1629 static wxPyCoreAPI API = {
1630
1631 wxPyCheckSwigType,
1632 wxPyConstructObject,
1633 wxPyConvertSwigPtr,
1634 wxPyMakeSwigPtr,
1635
1636 wxPyBeginAllowThreads,
1637 wxPyEndAllowThreads,
1638 wxPyBeginBlockThreads,
1639 wxPyEndBlockThreads,
1640
1641 wxPy_ConvertList,
1642
1643 wxString_in_helper,
1644 Py2wxString,
1645 wx2PyString,
1646
1647 byte_LIST_helper,
1648 int_LIST_helper,
1649 long_LIST_helper,
1650 string_LIST_helper,
1651 wxPoint_LIST_helper,
1652 wxBitmap_LIST_helper,
1653 wxString_LIST_helper,
1654 wxAcceleratorEntry_LIST_helper,
1655
1656 wxSize_helper,
1657 wxPoint_helper,
1658 wxRealPoint_helper,
1659 wxRect_helper,
1660 wxColour_helper,
1661 wxPoint2D_helper,
1662
1663 wxPySimple_typecheck,
1664 wxColour_typecheck,
1665
1666 wxPyCBH_setCallbackInfo,
1667 wxPyCBH_findCallback,
1668 wxPyCBH_callCallback,
1669 wxPyCBH_callCallbackObj,
1670 wxPyCBH_delete,
1671
1672 wxPyMake_wxObject,
1673 wxPyMake_wxSizer,
1674 wxPyPtrTypeMap_Add,
1675 wxPy2int_seq_helper,
1676 wxPy4int_seq_helper,
1677 wxArrayString2PyList_helper,
1678 wxArrayInt2PyList_helper,
1679
1680 wxPyClientData_dtor,
1681 wxPyUserData_dtor,
1682 wxPyOORClientData_dtor,
1683
1684 wxPyCBInputStream_create,
1685 wxPyCBInputStream_copy,
1686
1687 wxPyInstance_Check,
1688 wxPySwigInstance_Check,
1689
1690 wxPyCheckForApp
1691
1692 };
1693
1694 #endif
1695
1696
1697 #if !WXWIN_COMPATIBILITY_2_4
1698 #define wxHIDE_READONLY 0
1699 #endif
1700
1701
1702 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1703 #define SWIG_From_int PyInt_FromLong
1704 /*@@*/
1705
1706 static const wxString wxPyEmptyString(wxEmptyString);
1707 static wxString wxObject_GetClassName(wxObject *self){
1708 return self->GetClassInfo()->GetClassName();
1709 }
1710 static void wxObject_Destroy(wxObject *self){
1711 delete self;
1712 }
1713
1714 #ifndef __WXMAC__
1715 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1716 #endif
1717
1718
1719 #include <limits.h>
1720
1721
1722 SWIGINTERN int
1723 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1724 const char *errmsg)
1725 {
1726 if (value < min_value) {
1727 if (errmsg) {
1728 PyErr_Format(PyExc_OverflowError,
1729 "value %ld is less than '%s' minimum %ld",
1730 value, errmsg, min_value);
1731 }
1732 return 0;
1733 } else if (value > max_value) {
1734 if (errmsg) {
1735 PyErr_Format(PyExc_OverflowError,
1736 "value %ld is greater than '%s' maximum %ld",
1737 value, errmsg, max_value);
1738 }
1739 return 0;
1740 }
1741 return 1;
1742 }
1743
1744
1745 SWIGINTERN int
1746 SWIG_AsVal_long(PyObject* obj, long* val)
1747 {
1748 if (PyNumber_Check(obj)) {
1749 if (val) *val = PyInt_AsLong(obj);
1750 return 1;
1751 }
1752 else {
1753 SWIG_type_error("number", obj);
1754 }
1755 return 0;
1756 }
1757
1758
1759 #if INT_MAX != LONG_MAX
1760 SWIGINTERN int
1761 SWIG_AsVal_int(PyObject *obj, int *val)
1762 {
1763 const char* errmsg = val ? "int" : (char*)0;
1764 long v;
1765 if (SWIG_AsVal_long(obj, &v)) {
1766 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1767 if (val) *val = (int)(v);
1768 return 1;
1769 } else {
1770 return 0;
1771 }
1772 } else {
1773 PyErr_Clear();
1774 }
1775 if (val) {
1776 SWIG_type_error(errmsg, obj);
1777 }
1778 return 0;
1779 }
1780 #else
1781 SWIGINTERNSHORT int
1782 SWIG_AsVal_int(PyObject *obj, int *val)
1783 {
1784 return SWIG_AsVal_long(obj,(long*)val);
1785 }
1786 #endif
1787
1788
1789 SWIGINTERNSHORT int
1790 SWIG_As_int(PyObject* obj)
1791 {
1792 int v;
1793 if (!SWIG_AsVal_int(obj, &v)) {
1794 /*
1795 this is needed to make valgrind/purify happier.
1796 */
1797 memset((void*)&v, 0, sizeof(int));
1798 }
1799 return v;
1800 }
1801
1802
1803 SWIGINTERNSHORT int
1804 SWIG_Check_int(PyObject* obj)
1805 {
1806 return SWIG_AsVal_int(obj, (int*)0);
1807 }
1808
1809 static PyObject *wxSize_Get(wxSize *self){
1810 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1811 PyObject* tup = PyTuple_New(2);
1812 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1813 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1814 wxPyEndBlockThreads(blocked);
1815 return tup;
1816 }
1817
1818 SWIGINTERN int
1819 SWIG_AsVal_double(PyObject *obj, double* val)
1820 {
1821 if (PyNumber_Check(obj)) {
1822 if (val) *val = PyFloat_AsDouble(obj);
1823 return 1;
1824 }
1825 else {
1826 SWIG_type_error("number", obj);
1827 }
1828 return 0;
1829 }
1830
1831
1832 SWIGINTERNSHORT double
1833 SWIG_As_double(PyObject* obj)
1834 {
1835 double v;
1836 if (!SWIG_AsVal_double(obj, &v)) {
1837 /*
1838 this is needed to make valgrind/purify happier.
1839 */
1840 memset((void*)&v, 0, sizeof(double));
1841 }
1842 return v;
1843 }
1844
1845
1846 SWIGINTERNSHORT int
1847 SWIG_Check_double(PyObject* obj)
1848 {
1849 return SWIG_AsVal_double(obj, (double*)0);
1850 }
1851
1852
1853 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1854 #define SWIG_From_double PyFloat_FromDouble
1855 /*@@*/
1856
1857 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1858 self->x = x;
1859 self->y = y;
1860 }
1861 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1862 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1863 PyObject* tup = PyTuple_New(2);
1864 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1865 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1866 wxPyEndBlockThreads(blocked);
1867 return tup;
1868 }
1869
1870 SWIGINTERNSHORT long
1871 SWIG_As_long(PyObject* obj)
1872 {
1873 long v;
1874 if (!SWIG_AsVal_long(obj, &v)) {
1875 /*
1876 this is needed to make valgrind/purify happier.
1877 */
1878 memset((void*)&v, 0, sizeof(long));
1879 }
1880 return v;
1881 }
1882
1883
1884 SWIGINTERNSHORT int
1885 SWIG_Check_long(PyObject* obj)
1886 {
1887 return SWIG_AsVal_long(obj, (long*)0);
1888 }
1889
1890 static void wxPoint_Set(wxPoint *self,long x,long y){
1891 self->x = x;
1892 self->y = y;
1893 }
1894 static PyObject *wxPoint_Get(wxPoint *self){
1895 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1896 PyObject* tup = PyTuple_New(2);
1897 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1898 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1899 wxPyEndBlockThreads(blocked);
1900 return tup;
1901 }
1902 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1903 self->x = x;
1904 self->y = y;
1905 self->width = width;
1906 self->height = height;
1907 }
1908 static PyObject *wxRect_Get(wxRect *self){
1909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1910 PyObject* tup = PyTuple_New(4);
1911 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1912 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1913 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1914 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1915 wxPyEndBlockThreads(blocked);
1916 return tup;
1917 }
1918
1919 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1920 wxRegion reg1(*r1);
1921 wxRegion reg2(*r2);
1922 wxRect dest(0,0,0,0);
1923 PyObject* obj;
1924
1925 reg1.Intersect(reg2);
1926 dest = reg1.GetBox();
1927
1928 if (dest != wxRect(0,0,0,0)) {
1929 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1930 wxRect* newRect = new wxRect(dest);
1931 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1932 wxPyEndBlockThreads(blocked);
1933 return obj;
1934 }
1935 Py_INCREF(Py_None);
1936 return Py_None;
1937 }
1938
1939
1940 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1941 PyObject* o2;
1942 PyObject* o3;
1943
1944 if (!target) {
1945 target = o;
1946 } else if (target == Py_None) {
1947 Py_DECREF(Py_None);
1948 target = o;
1949 } else {
1950 if (!PyTuple_Check(target)) {
1951 o2 = target;
1952 target = PyTuple_New(1);
1953 PyTuple_SetItem(target, 0, o2);
1954 }
1955 o3 = PyTuple_New(1);
1956 PyTuple_SetItem(o3, 0, o);
1957
1958 o2 = target;
1959 target = PySequence_Concat(o2, o3);
1960 Py_DECREF(o2);
1961 Py_DECREF(o3);
1962 }
1963 return target;
1964 }
1965
1966
1967 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1968 self->m_x = x;
1969 self->m_y = y;
1970 }
1971 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1972 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1973 PyObject* tup = PyTuple_New(2);
1974 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1975 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1976 wxPyEndBlockThreads(blocked);
1977 return tup;
1978 }
1979
1980 #include "wx/wxPython/pyistream.h"
1981
1982 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1983 wxInputStream* wxis = wxPyCBInputStream::create(p);
1984 if (wxis)
1985 return new wxPyInputStream(wxis);
1986 else
1987 return NULL;
1988 }
1989
1990 SWIGINTERNSHORT PyObject*
1991 SWIG_From_char(char c)
1992 {
1993 return PyString_FromStringAndSize(&c,1);
1994 }
1995
1996
1997 SWIGINTERNSHORT PyObject*
1998 SWIG_From_unsigned_SS_long(unsigned long value)
1999 {
2000 return (value > LONG_MAX) ?
2001 PyLong_FromUnsignedLong(value)
2002 : PyInt_FromLong((long)(value));
2003 }
2004
2005
2006 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
2007 SWIGINTERN int
2008 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
2009 {
2010 static swig_type_info* pchar_info = 0;
2011 char* vptr = 0;
2012 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
2013 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
2014 if (cptr) *cptr = vptr;
2015 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
2016 return SWIG_OLDOBJ;
2017 } else {
2018 PyErr_Clear();
2019 if (PyString_Check(obj)) {
2020 if (cptr) {
2021 *cptr = PyString_AS_STRING(obj);
2022 if (psize) {
2023 *psize = PyString_GET_SIZE(obj) + 1;
2024 }
2025 }
2026 return SWIG_PYSTR;
2027 }
2028 }
2029 if (cptr) {
2030 SWIG_type_error("char *", obj);
2031 }
2032 return 0;
2033 }
2034
2035
2036 SWIGINTERN int
2037 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2038 {
2039 char* cptr; size_t csize;
2040 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2041 /* in C you can do:
2042
2043 char x[5] = "hello";
2044
2045 ie, assing the array using an extra '0' char.
2046 */
2047 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2048 if (csize <= size) {
2049 if (val) {
2050 if (csize) memcpy(val, cptr, csize);
2051 if (csize < size) memset(val + csize, 0, size - csize);
2052 }
2053 return 1;
2054 }
2055 }
2056 if (val) {
2057 PyErr_Format(PyExc_TypeError,
2058 "a char array of maximum size %lu is expected",
2059 (unsigned long) size);
2060 }
2061 return 0;
2062 }
2063
2064
2065 SWIGINTERN int
2066 SWIG_AsVal_char(PyObject *obj, char *val)
2067 {
2068 const char* errmsg = val ? "char" : (char*)0;
2069 long v;
2070 if (SWIG_AsVal_long(obj, &v)) {
2071 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2072 if (val) *val = (char)(v);
2073 return 1;
2074 } else {
2075 return 0;
2076 }
2077 } else {
2078 PyErr_Clear();
2079 return SWIG_AsCharArray(obj, val, 1);
2080 }
2081 }
2082
2083
2084 SWIGINTERNSHORT char
2085 SWIG_As_char(PyObject* obj)
2086 {
2087 char v;
2088 if (!SWIG_AsVal_char(obj, &v)) {
2089 /*
2090 this is needed to make valgrind/purify happier.
2091 */
2092 memset((void*)&v, 0, sizeof(char));
2093 }
2094 return v;
2095 }
2096
2097
2098 SWIGINTERNSHORT int
2099 SWIG_Check_char(PyObject* obj)
2100 {
2101 return SWIG_AsVal_char(obj, (char*)0);
2102 }
2103
2104
2105 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2106 #define SWIG_From_long PyInt_FromLong
2107 /*@@*/
2108
2109 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2110 // We use only strings for the streams, not unicode
2111 PyObject* str = PyObject_Str(obj);
2112 if (! str) {
2113 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2114 return;
2115 }
2116 self->Write(PyString_AS_STRING(str),
2117 PyString_GET_SIZE(str));
2118 Py_DECREF(str);
2119 }
2120
2121 #include "wx/wxPython/pyistream.h"
2122
2123
2124 class wxPyFileSystemHandler : public wxFileSystemHandler
2125 {
2126 public:
2127 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2128
2129 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2130 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2131 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2132 DEC_PYCALLBACK_STRING__pure(FindNext);
2133
2134 wxString GetProtocol(const wxString& location) {
2135 return wxFileSystemHandler::GetProtocol(location);
2136 }
2137
2138 wxString GetLeftLocation(const wxString& location) {
2139 return wxFileSystemHandler::GetLeftLocation(location);
2140 }
2141
2142 wxString GetAnchor(const wxString& location) {
2143 return wxFileSystemHandler::GetAnchor(location);
2144 }
2145
2146 wxString GetRightLocation(const wxString& location) {
2147 return wxFileSystemHandler::GetRightLocation(location);
2148 }
2149
2150 wxString GetMimeTypeFromExt(const wxString& location) {
2151 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2152 }
2153
2154 PYPRIVATE;
2155 };
2156
2157
2158 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2159 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2160 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2161 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2162
2163
2164 SWIGINTERN int
2165 SWIG_AsVal_bool(PyObject *obj, bool *val)
2166 {
2167 if (obj == Py_True) {
2168 if (val) *val = true;
2169 return 1;
2170 }
2171 if (obj == Py_False) {
2172 if (val) *val = false;
2173 return 1;
2174 }
2175 int res = 0;
2176 if (SWIG_AsVal_int(obj, &res)) {
2177 if (val) *val = res ? true : false;
2178 return 1;
2179 } else {
2180 PyErr_Clear();
2181 }
2182 if (val) {
2183 SWIG_type_error("bool", obj);
2184 }
2185 return 0;
2186 }
2187
2188
2189 SWIGINTERNSHORT bool
2190 SWIG_As_bool(PyObject* obj)
2191 {
2192 bool v;
2193 if (!SWIG_AsVal_bool(obj, &v)) {
2194 /*
2195 this is needed to make valgrind/purify happier.
2196 */
2197 memset((void*)&v, 0, sizeof(bool));
2198 }
2199 return v;
2200 }
2201
2202
2203 SWIGINTERNSHORT int
2204 SWIG_Check_bool(PyObject* obj)
2205 {
2206 return SWIG_AsVal_bool(obj, (bool*)0);
2207 }
2208
2209 static wxString FileSystem_URLToFileName(wxString const &url){
2210 wxFileName fname = wxFileSystem::URLToFileName(url);
2211 return fname.GetFullPath();
2212 }
2213
2214 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2215 wxImage& image,
2216 long type) {
2217 wxMemoryFSHandler::AddFile(filename, image, type);
2218 }
2219
2220 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2221 const wxBitmap& bitmap,
2222 long type) {
2223 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2224 }
2225
2226 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2227 PyObject* data) {
2228 if (! PyString_Check(data)) {
2229 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2230 "Expected string object"));
2231 return;
2232 }
2233
2234 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2235 void* ptr = (void*)PyString_AsString(data);
2236 size_t size = PyString_Size(data);
2237 wxPyEndBlockThreads(blocked);
2238
2239 wxMemoryFSHandler::AddFile(filename, ptr, size);
2240 }
2241
2242
2243 #include "wx/wxPython/pyistream.h"
2244
2245
2246 SWIGINTERN int
2247 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2248 {
2249 long v = 0;
2250 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2251 SWIG_type_error("unsigned number", obj);
2252 }
2253 else if (val)
2254 *val = (unsigned long)v;
2255 return 1;
2256 }
2257
2258
2259 SWIGINTERNSHORT int
2260 SWIG_CheckUnsignedLongInRange(unsigned long value,
2261 unsigned long max_value,
2262 const char *errmsg)
2263 {
2264 if (value > max_value) {
2265 if (errmsg) {
2266 PyErr_Format(PyExc_OverflowError,
2267 "value %lu is greater than '%s' minimum %lu",
2268 value, errmsg, max_value);
2269 }
2270 return 0;
2271 }
2272 return 1;
2273 }
2274
2275
2276 SWIGINTERN int
2277 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2278 {
2279 const char* errmsg = val ? "unsigned char" : (char*)0;
2280 unsigned long v;
2281 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2282 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2283 if (val) *val = (unsigned char)(v);
2284 return 1;
2285 } else {
2286 return 0;
2287 }
2288 } else {
2289 PyErr_Clear();
2290 }
2291 if (val) {
2292 SWIG_type_error(errmsg, obj);
2293 }
2294 return 0;
2295 }
2296
2297
2298 SWIGINTERNSHORT unsigned char
2299 SWIG_As_unsigned_SS_char(PyObject* obj)
2300 {
2301 unsigned char v;
2302 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2303 /*
2304 this is needed to make valgrind/purify happier.
2305 */
2306 memset((void*)&v, 0, sizeof(unsigned char));
2307 }
2308 return v;
2309 }
2310
2311
2312 SWIGINTERNSHORT int
2313 SWIG_Check_unsigned_SS_char(PyObject* obj)
2314 {
2315 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2316 }
2317
2318
2319 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2320 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2321 /*@@*/
2322
2323
2324
2325 SWIGINTERNSHORT unsigned long
2326 SWIG_As_unsigned_SS_long(PyObject* obj)
2327 {
2328 unsigned long v;
2329 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2330 /*
2331 this is needed to make valgrind/purify happier.
2332 */
2333 memset((void*)&v, 0, sizeof(unsigned long));
2334 }
2335 return v;
2336 }
2337
2338
2339 SWIGINTERNSHORT int
2340 SWIG_Check_unsigned_SS_long(PyObject* obj)
2341 {
2342 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2343 }
2344
2345 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2346 wxImageHistogramEntry e = (*self)[key];
2347 return e.value;
2348 }
2349 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2350 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2351 wxImageHistogramEntry e = (*self)[key];
2352 return e.value;
2353 }
2354 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2355 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2356 colour.Green(),
2357 colour.Blue());
2358 wxImageHistogramEntry e = (*self)[key];
2359 return e.value;
2360 }
2361
2362 typedef unsigned char* buffer;
2363
2364
2365 // Pull the nested class out to the top level for SWIG's sake
2366 #define wxImage_RGBValue wxImage::RGBValue
2367 #define wxImage_HSVValue wxImage::HSVValue
2368
2369 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2370 if (width > 0 && height > 0)
2371 return new wxImage(width, height, clear);
2372 else
2373 return new wxImage;
2374 }
2375 static wxImage *new_wxImage(wxBitmap const &bitmap){
2376 return new wxImage(bitmap.ConvertToImage());
2377 }
2378 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2379 if (DATASIZE != width*height*3) {
2380 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2381 return NULL;
2382 }
2383
2384 // Copy the source data so the wxImage can clean it up later
2385 buffer copy = (buffer)malloc(DATASIZE);
2386 if (copy == NULL) {
2387 wxPyBLOCK_THREADS(PyErr_NoMemory());
2388 return NULL;
2389 }
2390 memcpy(copy, data, DATASIZE);
2391 return new wxImage(width, height, copy, false);
2392 }
2393 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2394 if (DATASIZE != width*height*3) {
2395 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2396 return NULL;
2397 }
2398 if (ALPHASIZE != width*height) {
2399 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2400 return NULL;
2401 }
2402
2403 // Copy the source data so the wxImage can clean it up later
2404 buffer dcopy = (buffer)malloc(DATASIZE);
2405 if (dcopy == NULL) {
2406 wxPyBLOCK_THREADS(PyErr_NoMemory());
2407 return NULL;
2408 }
2409 memcpy(dcopy, data, DATASIZE);
2410
2411 buffer acopy = (buffer)malloc(ALPHASIZE);
2412 if (acopy == NULL) {
2413 wxPyBLOCK_THREADS(PyErr_NoMemory());
2414 return NULL;
2415 }
2416 memcpy(acopy, alpha, ALPHASIZE);
2417
2418 return new wxImage(width, height, dcopy, acopy, false);
2419 }
2420 static wxSize wxImage_GetSize(wxImage *self){
2421 wxSize size(self->GetWidth(), self->GetHeight());
2422 return size;
2423 }
2424 static PyObject *wxImage_GetData(wxImage *self){
2425 buffer data = self->GetData();
2426 int len = self->GetWidth() * self->GetHeight() * 3;
2427 PyObject* rv;
2428 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2429 return rv;
2430 }
2431 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2432 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2433 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2434 return;
2435 }
2436 buffer copy = (buffer)malloc(DATASIZE);
2437 if (copy == NULL) {
2438 wxPyBLOCK_THREADS(PyErr_NoMemory());
2439 return;
2440 }
2441 memcpy(copy, data, DATASIZE);
2442 self->SetData(copy, false);
2443 // wxImage takes ownership of copy...
2444 }
2445 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2446 buffer data = self->GetData();
2447 int len = self->GetWidth() * self->GetHeight() * 3;
2448 PyObject* rv;
2449 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2450 return rv;
2451 }
2452 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2453 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2454 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2455 return;
2456 }
2457 self->SetData(data, true);
2458 }
2459 static PyObject *wxImage_GetAlphaData(wxImage *self){
2460 buffer data = self->GetAlpha();
2461 if (! data) {
2462 RETURN_NONE();
2463 } else {
2464 int len = self->GetWidth() * self->GetHeight();
2465 PyObject* rv;
2466 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2467 return rv;
2468 }
2469 }
2470 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2471 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2472 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2473 return;
2474 }
2475 buffer acopy = (buffer)malloc(ALPHASIZE);
2476 if (acopy == NULL) {
2477 wxPyBLOCK_THREADS(PyErr_NoMemory());
2478 return;
2479 }
2480 memcpy(acopy, alpha, ALPHASIZE);
2481 self->SetAlpha(acopy, false);
2482 // wxImage takes ownership of acopy...
2483 }
2484 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2485 buffer data = self->GetAlpha();
2486 int len = self->GetWidth() * self->GetHeight();
2487 PyObject* rv;
2488 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2489 return rv;
2490 }
2491 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2492 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2493 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2494 return;
2495 }
2496 self->SetAlpha(alpha, true);
2497 }
2498 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2499 wxBitmap bitmap(*self, depth);
2500 return bitmap;
2501 }
2502 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2503 wxImage mono = self->ConvertToMono( red, green, blue );
2504 wxBitmap bitmap( mono, 1 );
2505 return bitmap;
2506 }
2507 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2508 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2509 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2510 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2511 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2512 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2513 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2514 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2515 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2516 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2517 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2518 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2519 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2520 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2521 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2522
2523 #include <wx/quantize.h>
2524
2525 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2526 return wxQuantize::Quantize(src, dest,
2527 //NULL, // palette
2528 desiredNoColours,
2529 NULL, // eightBitData
2530 flags);
2531 }
2532 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2533 if (PyCallable_Check(func)) {
2534 self->Connect(id, lastId, eventType,
2535 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2536 new wxPyCallback(func));
2537 }
2538 else if (func == Py_None) {
2539 self->Disconnect(id, lastId, eventType,
2540 (wxObjectEventFunction)
2541 &wxPyCallback::EventThunker);
2542 }
2543 else {
2544 wxPyBLOCK_THREADS(
2545 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2546 }
2547 }
2548 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2549 return self->Disconnect(id, lastId, eventType,
2550 (wxObjectEventFunction)
2551 &wxPyCallback::EventThunker);
2552 }
2553 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2554 if (_self && _self != Py_None) {
2555 self->SetClientObject(new wxPyOORClientData(_self, incref));
2556 }
2557 else {
2558 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2559 if (data) {
2560 self->SetClientObject(NULL); // This will delete it too
2561 }
2562 }
2563 }
2564
2565 #if ! wxUSE_HOTKEY
2566 #define wxEVT_HOTKEY -9999
2567 #endif
2568
2569
2570 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2571 #if wxUSE_UNICODE
2572 return self->GetUnicodeKey();
2573 #else
2574 return 0;
2575 #endif
2576 }
2577
2578 #if UINT_MAX < LONG_MAX
2579 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2580 #define SWIG_From_unsigned_SS_int SWIG_From_long
2581 /*@@*/
2582 #else
2583 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2584 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2585 /*@@*/
2586 #endif
2587
2588
2589 #if UINT_MAX != ULONG_MAX
2590 SWIGINTERN int
2591 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2592 {
2593 const char* errmsg = val ? "unsigned int" : (char*)0;
2594 unsigned long v;
2595 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2596 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2597 if (val) *val = (unsigned int)(v);
2598 return 1;
2599 }
2600 } else {
2601 PyErr_Clear();
2602 }
2603 if (val) {
2604 SWIG_type_error(errmsg, obj);
2605 }
2606 return 0;
2607 }
2608 #else
2609 SWIGINTERNSHORT unsigned int
2610 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2611 {
2612 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2613 }
2614 #endif
2615
2616
2617 SWIGINTERNSHORT unsigned int
2618 SWIG_As_unsigned_SS_int(PyObject* obj)
2619 {
2620 unsigned int v;
2621 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2622 /*
2623 this is needed to make valgrind/purify happier.
2624 */
2625 memset((void*)&v, 0, sizeof(unsigned int));
2626 }
2627 return v;
2628 }
2629
2630
2631 SWIGINTERNSHORT int
2632 SWIG_Check_unsigned_SS_int(PyObject* obj)
2633 {
2634 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2635 }
2636
2637 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2638 self->m_size = size;
2639 }
2640 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2641 int count = self->GetNumberOfFiles();
2642 wxString* files = self->GetFiles();
2643 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2644 PyObject* list = PyList_New(count);
2645
2646 if (!list) {
2647 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2648 wxPyEndBlockThreads(blocked);
2649 return NULL;
2650 }
2651
2652 for (int i=0; i<count; i++) {
2653 PyList_SetItem(list, i, wx2PyString(files[i]));
2654 }
2655 wxPyEndBlockThreads(blocked);
2656 return list;
2657 }
2658
2659
2660 static wxPyApp *new_wxPyApp(){
2661 wxPythonApp = new wxPyApp();
2662 return wxPythonApp;
2663 }
2664 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2665
2666 void wxApp_CleanUp() {
2667 __wxPyCleanup();
2668 }
2669
2670
2671 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2672
2673
2674 SWIGINTERNSHORT int
2675 SWIG_AsCharPtr(PyObject *obj, char **val)
2676 {
2677 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2678 return 1;
2679 }
2680 if (val) {
2681 PyErr_Clear();
2682 SWIG_type_error("char *", obj);
2683 }
2684 return 0;
2685 }
2686
2687
2688 SWIGINTERN PyObject *
2689 SWIG_FromCharPtr(const char* cptr)
2690 {
2691 if (cptr) {
2692 size_t size = strlen(cptr);
2693 if (size > INT_MAX) {
2694 return SWIG_NewPointerObj((char*)(cptr),
2695 SWIG_TypeQuery("char *"), 0);
2696 } else {
2697 if (size != 0) {
2698 return PyString_FromStringAndSize(cptr, size);
2699 } else {
2700 return PyString_FromString(cptr);
2701 }
2702 }
2703 }
2704 Py_INCREF(Py_None);
2705 return Py_None;
2706 }
2707
2708
2709 #if 0 // #ifdef __WXMAC__
2710
2711 // A dummy class that raises an exception if used...
2712 class wxEventLoop
2713 {
2714 public:
2715 wxEventLoop() { wxPyRaiseNotImplemented(); }
2716 int Run() { return 0; }
2717 void Exit(int rc = 0) {}
2718 bool Pending() const { return false; }
2719 bool Dispatch() { return false; }
2720 bool IsRunning() const { return false; }
2721 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2722 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2723 };
2724
2725 #else
2726
2727 #include <wx/evtloop.h>
2728
2729 #endif
2730
2731
2732
2733 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2734 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2735 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2736 static PyObject *wxWindow_GetChildren(wxWindow *self){
2737 wxWindowList& list = self->GetChildren();
2738 return wxPy_ConvertList(&list);
2739 }
2740 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2741 #if wxUSE_HOTKEY
2742 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2743 #else
2744 return false;
2745 #endif
2746 }
2747 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2748
2749
2750
2751 return false;
2752
2753 }
2754 static long wxWindow_GetHandle(wxWindow *self){
2755 return wxPyGetWinHandle(self);
2756 }
2757 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2758 self->AssociateHandle((WXWidget)handle);
2759 }
2760 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
2761
2762 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2763 return wxWindow::FindWindowById(id, parent);
2764 }
2765
2766 wxWindow* wxFindWindowByName( const wxString& name,
2767 const wxWindow *parent = NULL ) {
2768 return wxWindow::FindWindowByName(name, parent);
2769 }
2770
2771 wxWindow* wxFindWindowByLabel( const wxString& label,
2772 const wxWindow *parent = NULL ) {
2773 return wxWindow::FindWindowByLabel(label, parent);
2774 }
2775
2776
2777 #ifdef __WXMSW__
2778 #include <wx/msw/private.h> // to get wxGetWindowId
2779 #endif
2780
2781
2782 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2783 #ifdef __WXMSW__
2784 WXHWND hWnd = (WXHWND)_hWnd;
2785 long id = wxGetWindowId(hWnd);
2786 wxWindow* win = new wxWindow;
2787 if (parent)
2788 parent->AddChild(win);
2789 win->SetEventHandler(win);
2790 win->SetHWND(hWnd);
2791 win->SetId(id);
2792 win->SubclassWin(hWnd);
2793 win->AdoptAttributesFromHWND();
2794 win->SetupColours();
2795 return win;
2796 #else
2797 wxPyRaiseNotImplemented();
2798 return NULL;
2799 #endif
2800 }
2801
2802
2803 PyObject* GetTopLevelWindows() {
2804 return wxPy_ConvertList(&wxTopLevelWindows);
2805 }
2806
2807
2808 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2809 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2810 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2811
2812 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2813
2814 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2815 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2816 wxMenuItemList& list = self->GetMenuItems();
2817 return wxPy_ConvertList(&list);
2818 }
2819 static void MenuBar_SetAutoWindowMenu(bool enable){}
2820 static bool MenuBar_GetAutoWindowMenu(){ return false; }
2821 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2822 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2823 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2824 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2825 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2826 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2827 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
2828 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2829 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2830 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2831 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2832 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2833 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2834 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2835 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2836 static const wxString wxPyControlNameStr(wxControlNameStr);
2837 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2838 if (clientData) {
2839 wxPyClientData* data = new wxPyClientData(clientData);
2840 return self->Append(item, data);
2841 } else
2842 return self->Append(item);
2843 }
2844 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2845 if (clientData) {
2846 wxPyClientData* data = new wxPyClientData(clientData);
2847 return self->Insert(item, pos, data);
2848 } else
2849 return self->Insert(item, pos);
2850 }
2851 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2852 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2853 if (data) {
2854 Py_INCREF(data->m_obj);
2855 return data->m_obj;
2856 } else {
2857 Py_INCREF(Py_None);
2858 return Py_None;
2859 }
2860 }
2861 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2862 wxPyClientData* data = new wxPyClientData(clientData);
2863 self->SetClientObject(n, data);
2864 }
2865
2866
2867 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2868 wxPyUserData* data = NULL;
2869 if ( userData ) {
2870 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2871 data = new wxPyUserData(userData);
2872 wxPyEndBlockThreads(blocked);
2873 }
2874 return new wxSizerItem(window, proportion, flag, border, data);
2875 }
2876 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2877 wxPyUserData* data = NULL;
2878 if ( userData ) {
2879 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2880 data = new wxPyUserData(userData);
2881 wxPyEndBlockThreads(blocked);
2882 }
2883 return new wxSizerItem(width, height, proportion, flag, border, data);
2884 }
2885 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2886 wxPyUserData* data = NULL;
2887 if ( userData ) {
2888 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2889 data = new wxPyUserData(userData);
2890 wxPyEndBlockThreads(blocked);
2891 }
2892 return new wxSizerItem(sizer, proportion, flag, border, data);
2893 }
2894
2895 #include <float.h>
2896 SWIGINTERN int
2897 SWIG_CheckDoubleInRange(double value, double min_value,
2898 double max_value, const char* errmsg)
2899 {
2900 if (value < min_value) {
2901 if (errmsg) {
2902 PyErr_Format(PyExc_OverflowError,
2903 "value %g is less than %s minimum %g",
2904 value, errmsg, min_value);
2905 }
2906 return 0;
2907 } else if (value > max_value) {
2908 if (errmsg) {
2909 PyErr_Format(PyExc_OverflowError,
2910 "value %g is greater than %s maximum %g",
2911 value, errmsg, max_value);
2912 }
2913 return 0;
2914 }
2915 return 1;
2916 }
2917
2918
2919 SWIGINTERN int
2920 SWIG_AsVal_float(PyObject *obj, float *val)
2921 {
2922 const char* errmsg = val ? "float" : (char*)0;
2923 double v;
2924 if (SWIG_AsVal_double(obj, &v)) {
2925 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2926 if (val) *val = (float)(v);
2927 return 1;
2928 } else {
2929 return 0;
2930 }
2931 } else {
2932 PyErr_Clear();
2933 }
2934 if (val) {
2935 SWIG_type_error(errmsg, obj);
2936 }
2937 return 0;
2938 }
2939
2940
2941 SWIGINTERNSHORT float
2942 SWIG_As_float(PyObject* obj)
2943 {
2944 float v;
2945 if (!SWIG_AsVal_float(obj, &v)) {
2946 /*
2947 this is needed to make valgrind/purify happier.
2948 */
2949 memset((void*)&v, 0, sizeof(float));
2950 }
2951 return v;
2952 }
2953
2954
2955 SWIGINTERNSHORT int
2956 SWIG_Check_float(PyObject* obj)
2957 {
2958 return SWIG_AsVal_float(obj, (float*)0);
2959 }
2960
2961
2962 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2963 #define SWIG_From_float PyFloat_FromDouble
2964 /*@@*/
2965
2966 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2967 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2968 if (data) {
2969 Py_INCREF(data->m_obj);
2970 return data->m_obj;
2971 } else {
2972 Py_INCREF(Py_None);
2973 return Py_None;
2974 }
2975 }
2976 static void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
2977 wxPyUserData* data = NULL;
2978 if ( userData ) {
2979 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2980 data = new wxPyUserData(userData);
2981 wxPyEndBlockThreads(blocked);
2982 }
2983 self->SetUserData(data);
2984 }
2985
2986 // Figure out the type of the sizer item
2987
2988 struct wxPySizerItemInfo {
2989 wxPySizerItemInfo()
2990 : window(NULL), sizer(NULL), gotSize(false),
2991 size(wxDefaultSize), gotPos(false), pos(-1)
2992 {}
2993
2994 wxWindow* window;
2995 wxSizer* sizer;
2996 bool gotSize;
2997 wxSize size;
2998 bool gotPos;
2999 int pos;
3000 };
3001
3002 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3003
3004 wxPySizerItemInfo info;
3005 wxSize size;
3006 wxSize* sizePtr = &size;
3007
3008 // Find out what the type of the item is
3009 // try wxWindow
3010 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3011 PyErr_Clear();
3012 info.window = NULL;
3013
3014 // try wxSizer
3015 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3016 PyErr_Clear();
3017 info.sizer = NULL;
3018
3019 // try wxSize or (w,h)
3020 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3021 info.size = *sizePtr;
3022 info.gotSize = true;
3023 }
3024
3025 // or a single int
3026 if (checkIdx && PyInt_Check(item)) {
3027 info.pos = PyInt_AsLong(item);
3028 info.gotPos = true;
3029 }
3030 }
3031 }
3032
3033 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3034 // no expected type, figure out what kind of error message to generate
3035 if ( !checkSize && !checkIdx )
3036 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3037 else if ( checkSize && !checkIdx )
3038 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3039 else if ( !checkSize && checkIdx)
3040 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3041 else
3042 // can this one happen?
3043 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3044 }
3045
3046 return info;
3047 }
3048
3049 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3050 if (!self->GetClientObject())
3051 self->SetClientObject(new wxPyOORClientData(_self));
3052 }
3053 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3054
3055 wxPyUserData* data = NULL;
3056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3057 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3058 if ( userData && (info.window || info.sizer || info.gotSize) )
3059 data = new wxPyUserData(userData);
3060 wxPyEndBlockThreads(blocked);
3061
3062 // Now call the real Add method if a valid item type was found
3063 if ( info.window )
3064 return self->Add(info.window, proportion, flag, border, data);
3065 else if ( info.sizer )
3066 return self->Add(info.sizer, proportion, flag, border, data);
3067 else if (info.gotSize)
3068 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3069 proportion, flag, border, data);
3070 else
3071 return NULL;
3072 }
3073 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3074
3075 wxPyUserData* data = NULL;
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3078 if ( userData && (info.window || info.sizer || info.gotSize) )
3079 data = new wxPyUserData(userData);
3080 wxPyEndBlockThreads(blocked);
3081
3082 // Now call the real Insert method if a valid item type was found
3083 if ( info.window )
3084 return self->Insert(before, info.window, proportion, flag, border, data);
3085 else if ( info.sizer )
3086 return self->Insert(before, info.sizer, proportion, flag, border, data);
3087 else if (info.gotSize)
3088 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3089 proportion, flag, border, data);
3090 else
3091 return NULL;
3092 }
3093 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3094
3095 wxPyUserData* data = NULL;
3096 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3097 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3098 if ( userData && (info.window || info.sizer || info.gotSize) )
3099 data = new wxPyUserData(userData);
3100 wxPyEndBlockThreads(blocked);
3101
3102 // Now call the real Prepend method if a valid item type was found
3103 if ( info.window )
3104 return self->Prepend(info.window, proportion, flag, border, data);
3105 else if ( info.sizer )
3106 return self->Prepend(info.sizer, proportion, flag, border, data);
3107 else if (info.gotSize)
3108 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3109 proportion, flag, border, data);
3110 else
3111 return NULL;
3112 }
3113 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3114 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3115 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3116 wxPyEndBlockThreads(blocked);
3117 if ( info.window )
3118 return self->Remove(info.window);
3119 else if ( info.sizer )
3120 return self->Remove(info.sizer);
3121 else if ( info.gotPos )
3122 return self->Remove(info.pos);
3123 else
3124 return false;
3125 }
3126 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3127 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3128 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3129 wxPyEndBlockThreads(blocked);
3130 if ( info.window )
3131 return self->Detach(info.window);
3132 else if ( info.sizer )
3133 return self->Detach(info.sizer);
3134 else if ( info.gotPos )
3135 return self->Detach(info.pos);
3136 else
3137 return false;
3138 }
3139 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3140 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3141 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3142 wxPyEndBlockThreads(blocked);
3143 if ( info.window )
3144 return self->GetItem(info.window);
3145 else if ( info.sizer )
3146 return self->GetItem(info.sizer);
3147 else if ( info.gotPos )
3148 return self->GetItem(info.pos);
3149 else
3150 return NULL;
3151 }
3152 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3153 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3154 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3155 wxPyEndBlockThreads(blocked);
3156 if ( info.window )
3157 self->SetItemMinSize(info.window, size);
3158 else if ( info.sizer )
3159 self->SetItemMinSize(info.sizer, size);
3160 else if ( info.gotPos )
3161 self->SetItemMinSize(info.pos, size);
3162 }
3163 static PyObject *wxSizer_GetChildren(wxSizer *self){
3164 wxSizerItemList& list = self->GetChildren();
3165 return wxPy_ConvertList(&list);
3166 }
3167 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3168 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3169 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3170 wxPyEndBlockThreads(blocked);
3171 if ( info.window )
3172 return self->Show(info.window, show, recursive);
3173 else if ( info.sizer )
3174 return self->Show(info.sizer, show, recursive);
3175 else if ( info.gotPos )
3176 return self->Show(info.pos, show);
3177 else
3178 return false;
3179 }
3180 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3182 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3183 wxPyEndBlockThreads(blocked);
3184 if ( info.window )
3185 return self->IsShown(info.window);
3186 else if ( info.sizer )
3187 return self->IsShown(info.sizer);
3188 else if ( info.gotPos )
3189 return self->IsShown(info.pos);
3190 else
3191 return false;
3192 }
3193
3194 // See pyclasses.h
3195 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3196 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3197 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3198
3199
3200
3201
3202 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3203 {
3204 if (source == Py_None) {
3205 **obj = wxGBPosition(-1,-1);
3206 return true;
3207 }
3208 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3209 }
3210
3211 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3212 {
3213 if (source == Py_None) {
3214 **obj = wxGBSpan(-1,-1);
3215 return true;
3216 }
3217 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3218 }
3219
3220
3221 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3222 self->SetRow(row);
3223 self->SetCol(col);
3224 }
3225 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3226 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3227 PyObject* tup = PyTuple_New(2);
3228 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3229 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3230 wxPyEndBlockThreads(blocked);
3231 return tup;
3232 }
3233 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3234 self->SetRowspan(rowspan);
3235 self->SetColspan(colspan);
3236 }
3237 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3238 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3239 PyObject* tup = PyTuple_New(2);
3240 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3241 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3242 wxPyEndBlockThreads(blocked);
3243 return tup;
3244 }
3245 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3246 wxPyUserData* data = NULL;
3247 if ( userData ) {
3248 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3249 data = new wxPyUserData(userData);
3250 wxPyEndBlockThreads(blocked);
3251 }
3252 return new wxGBSizerItem(window, pos, span, flag, border, data);
3253 }
3254 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3255 wxPyUserData* data = NULL;
3256 if ( userData ) {
3257 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3258 data = new wxPyUserData(userData);
3259 wxPyEndBlockThreads(blocked);
3260 }
3261 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3262 }
3263 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3264 wxPyUserData* data = NULL;
3265 if ( userData ) {
3266 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3267 data = new wxPyUserData(userData);
3268 wxPyEndBlockThreads(blocked);
3269 }
3270 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3271 }
3272 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3273 int row, col;
3274 self->GetEndPos(row, col);
3275 return wxGBPosition(row, col);
3276 }
3277 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3278
3279 wxPyUserData* data = NULL;
3280 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3281 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3282 if ( userData && (info.window || info.sizer || info.gotSize) )
3283 data = new wxPyUserData(userData);
3284 wxPyEndBlockThreads(blocked);
3285
3286 // Now call the real Add method if a valid item type was found
3287 if ( info.window )
3288 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3289 else if ( info.sizer )
3290 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3291 else if (info.gotSize)
3292 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3293 pos, span, flag, border, data);
3294 return NULL;
3295 }
3296
3297
3298 #ifdef __cplusplus
3299 extern "C" {
3300 #endif
3301 static int _wrap_EmptyString_set(PyObject *) {
3302 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3303 return 1;
3304 }
3305
3306
3307 static PyObject *_wrap_EmptyString_get(void) {
3308 PyObject *pyobj;
3309
3310 {
3311 #if wxUSE_UNICODE
3312 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3313 #else
3314 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3315 #endif
3316 }
3317 return pyobj;
3318 }
3319
3320
3321 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3322 PyObject *resultobj;
3323 wxObject *arg1 = (wxObject *) 0 ;
3324 wxString result;
3325 PyObject * obj0 = 0 ;
3326 char *kwnames[] = {
3327 (char *) "self", NULL
3328 };
3329
3330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3332 if (SWIG_arg_fail(1)) SWIG_fail;
3333 {
3334 PyThreadState* __tstate = wxPyBeginAllowThreads();
3335 result = wxObject_GetClassName(arg1);
3336
3337 wxPyEndAllowThreads(__tstate);
3338 if (PyErr_Occurred()) SWIG_fail;
3339 }
3340 {
3341 #if wxUSE_UNICODE
3342 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3343 #else
3344 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3345 #endif
3346 }
3347 return resultobj;
3348 fail:
3349 return NULL;
3350 }
3351
3352
3353 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3354 PyObject *resultobj;
3355 wxObject *arg1 = (wxObject *) 0 ;
3356 PyObject * obj0 = 0 ;
3357 char *kwnames[] = {
3358 (char *) "self", NULL
3359 };
3360
3361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3363 if (SWIG_arg_fail(1)) SWIG_fail;
3364 {
3365 PyThreadState* __tstate = wxPyBeginAllowThreads();
3366 wxObject_Destroy(arg1);
3367
3368 wxPyEndAllowThreads(__tstate);
3369 if (PyErr_Occurred()) SWIG_fail;
3370 }
3371 Py_INCREF(Py_None); resultobj = Py_None;
3372 return resultobj;
3373 fail:
3374 return NULL;
3375 }
3376
3377
3378 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3379 PyObject *obj;
3380 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3381 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3382 Py_INCREF(obj);
3383 return Py_BuildValue((char *)"");
3384 }
3385 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3386 PyObject *resultobj;
3387 wxSize *arg1 = (wxSize *) 0 ;
3388 int arg2 ;
3389 PyObject * obj0 = 0 ;
3390 PyObject * obj1 = 0 ;
3391 char *kwnames[] = {
3392 (char *) "self",(char *) "x", NULL
3393 };
3394
3395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3397 if (SWIG_arg_fail(1)) SWIG_fail;
3398 {
3399 arg2 = (int)(SWIG_As_int(obj1));
3400 if (SWIG_arg_fail(2)) SWIG_fail;
3401 }
3402 if (arg1) (arg1)->x = arg2;
3403
3404 Py_INCREF(Py_None); resultobj = Py_None;
3405 return resultobj;
3406 fail:
3407 return NULL;
3408 }
3409
3410
3411 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3412 PyObject *resultobj;
3413 wxSize *arg1 = (wxSize *) 0 ;
3414 int result;
3415 PyObject * obj0 = 0 ;
3416 char *kwnames[] = {
3417 (char *) "self", NULL
3418 };
3419
3420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3422 if (SWIG_arg_fail(1)) SWIG_fail;
3423 result = (int) ((arg1)->x);
3424
3425 {
3426 resultobj = SWIG_From_int((int)(result));
3427 }
3428 return resultobj;
3429 fail:
3430 return NULL;
3431 }
3432
3433
3434 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3435 PyObject *resultobj;
3436 wxSize *arg1 = (wxSize *) 0 ;
3437 int arg2 ;
3438 PyObject * obj0 = 0 ;
3439 PyObject * obj1 = 0 ;
3440 char *kwnames[] = {
3441 (char *) "self",(char *) "y", NULL
3442 };
3443
3444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3446 if (SWIG_arg_fail(1)) SWIG_fail;
3447 {
3448 arg2 = (int)(SWIG_As_int(obj1));
3449 if (SWIG_arg_fail(2)) SWIG_fail;
3450 }
3451 if (arg1) (arg1)->y = arg2;
3452
3453 Py_INCREF(Py_None); resultobj = Py_None;
3454 return resultobj;
3455 fail:
3456 return NULL;
3457 }
3458
3459
3460 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3461 PyObject *resultobj;
3462 wxSize *arg1 = (wxSize *) 0 ;
3463 int result;
3464 PyObject * obj0 = 0 ;
3465 char *kwnames[] = {
3466 (char *) "self", NULL
3467 };
3468
3469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3471 if (SWIG_arg_fail(1)) SWIG_fail;
3472 result = (int) ((arg1)->y);
3473
3474 {
3475 resultobj = SWIG_From_int((int)(result));
3476 }
3477 return resultobj;
3478 fail:
3479 return NULL;
3480 }
3481
3482
3483 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3484 PyObject *resultobj;
3485 int arg1 = (int) 0 ;
3486 int arg2 = (int) 0 ;
3487 wxSize *result;
3488 PyObject * obj0 = 0 ;
3489 PyObject * obj1 = 0 ;
3490 char *kwnames[] = {
3491 (char *) "w",(char *) "h", NULL
3492 };
3493
3494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3495 if (obj0) {
3496 {
3497 arg1 = (int)(SWIG_As_int(obj0));
3498 if (SWIG_arg_fail(1)) SWIG_fail;
3499 }
3500 }
3501 if (obj1) {
3502 {
3503 arg2 = (int)(SWIG_As_int(obj1));
3504 if (SWIG_arg_fail(2)) SWIG_fail;
3505 }
3506 }
3507 {
3508 PyThreadState* __tstate = wxPyBeginAllowThreads();
3509 result = (wxSize *)new wxSize(arg1,arg2);
3510
3511 wxPyEndAllowThreads(__tstate);
3512 if (PyErr_Occurred()) SWIG_fail;
3513 }
3514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3515 return resultobj;
3516 fail:
3517 return NULL;
3518 }
3519
3520
3521 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3522 PyObject *resultobj;
3523 wxSize *arg1 = (wxSize *) 0 ;
3524 PyObject * obj0 = 0 ;
3525 char *kwnames[] = {
3526 (char *) "self", NULL
3527 };
3528
3529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3531 if (SWIG_arg_fail(1)) SWIG_fail;
3532 {
3533 PyThreadState* __tstate = wxPyBeginAllowThreads();
3534 delete arg1;
3535
3536 wxPyEndAllowThreads(__tstate);
3537 if (PyErr_Occurred()) SWIG_fail;
3538 }
3539 Py_INCREF(Py_None); resultobj = Py_None;
3540 return resultobj;
3541 fail:
3542 return NULL;
3543 }
3544
3545
3546 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3547 PyObject *resultobj;
3548 wxSize *arg1 = (wxSize *) 0 ;
3549 wxSize *arg2 = 0 ;
3550 bool result;
3551 wxSize temp2 ;
3552 PyObject * obj0 = 0 ;
3553 PyObject * obj1 = 0 ;
3554 char *kwnames[] = {
3555 (char *) "self",(char *) "sz", NULL
3556 };
3557
3558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3560 if (SWIG_arg_fail(1)) SWIG_fail;
3561 {
3562 arg2 = &temp2;
3563 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3564 }
3565 {
3566 PyThreadState* __tstate = wxPyBeginAllowThreads();
3567 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3568
3569 wxPyEndAllowThreads(__tstate);
3570 if (PyErr_Occurred()) SWIG_fail;
3571 }
3572 {
3573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3574 }
3575 return resultobj;
3576 fail:
3577 return NULL;
3578 }
3579
3580
3581 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3582 PyObject *resultobj;
3583 wxSize *arg1 = (wxSize *) 0 ;
3584 wxSize *arg2 = 0 ;
3585 bool result;
3586 wxSize temp2 ;
3587 PyObject * obj0 = 0 ;
3588 PyObject * obj1 = 0 ;
3589 char *kwnames[] = {
3590 (char *) "self",(char *) "sz", NULL
3591 };
3592
3593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3595 if (SWIG_arg_fail(1)) SWIG_fail;
3596 {
3597 arg2 = &temp2;
3598 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3599 }
3600 {
3601 PyThreadState* __tstate = wxPyBeginAllowThreads();
3602 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3603
3604 wxPyEndAllowThreads(__tstate);
3605 if (PyErr_Occurred()) SWIG_fail;
3606 }
3607 {
3608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3609 }
3610 return resultobj;
3611 fail:
3612 return NULL;
3613 }
3614
3615
3616 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3617 PyObject *resultobj;
3618 wxSize *arg1 = (wxSize *) 0 ;
3619 wxSize *arg2 = 0 ;
3620 wxSize result;
3621 wxSize temp2 ;
3622 PyObject * obj0 = 0 ;
3623 PyObject * obj1 = 0 ;
3624 char *kwnames[] = {
3625 (char *) "self",(char *) "sz", NULL
3626 };
3627
3628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3630 if (SWIG_arg_fail(1)) SWIG_fail;
3631 {
3632 arg2 = &temp2;
3633 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3634 }
3635 {
3636 PyThreadState* __tstate = wxPyBeginAllowThreads();
3637 result = (arg1)->operator +((wxSize const &)*arg2);
3638
3639 wxPyEndAllowThreads(__tstate);
3640 if (PyErr_Occurred()) SWIG_fail;
3641 }
3642 {
3643 wxSize * resultptr;
3644 resultptr = new wxSize((wxSize &)(result));
3645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3646 }
3647 return resultobj;
3648 fail:
3649 return NULL;
3650 }
3651
3652
3653 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3654 PyObject *resultobj;
3655 wxSize *arg1 = (wxSize *) 0 ;
3656 wxSize *arg2 = 0 ;
3657 wxSize result;
3658 wxSize temp2 ;
3659 PyObject * obj0 = 0 ;
3660 PyObject * obj1 = 0 ;
3661 char *kwnames[] = {
3662 (char *) "self",(char *) "sz", NULL
3663 };
3664
3665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3667 if (SWIG_arg_fail(1)) SWIG_fail;
3668 {
3669 arg2 = &temp2;
3670 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3671 }
3672 {
3673 PyThreadState* __tstate = wxPyBeginAllowThreads();
3674 result = (arg1)->operator -((wxSize const &)*arg2);
3675
3676 wxPyEndAllowThreads(__tstate);
3677 if (PyErr_Occurred()) SWIG_fail;
3678 }
3679 {
3680 wxSize * resultptr;
3681 resultptr = new wxSize((wxSize &)(result));
3682 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3683 }
3684 return resultobj;
3685 fail:
3686 return NULL;
3687 }
3688
3689
3690 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3691 PyObject *resultobj;
3692 wxSize *arg1 = (wxSize *) 0 ;
3693 wxSize *arg2 = 0 ;
3694 wxSize temp2 ;
3695 PyObject * obj0 = 0 ;
3696 PyObject * obj1 = 0 ;
3697 char *kwnames[] = {
3698 (char *) "self",(char *) "sz", NULL
3699 };
3700
3701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3703 if (SWIG_arg_fail(1)) SWIG_fail;
3704 {
3705 arg2 = &temp2;
3706 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3707 }
3708 {
3709 PyThreadState* __tstate = wxPyBeginAllowThreads();
3710 (arg1)->IncTo((wxSize const &)*arg2);
3711
3712 wxPyEndAllowThreads(__tstate);
3713 if (PyErr_Occurred()) SWIG_fail;
3714 }
3715 Py_INCREF(Py_None); resultobj = Py_None;
3716 return resultobj;
3717 fail:
3718 return NULL;
3719 }
3720
3721
3722 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3723 PyObject *resultobj;
3724 wxSize *arg1 = (wxSize *) 0 ;
3725 wxSize *arg2 = 0 ;
3726 wxSize temp2 ;
3727 PyObject * obj0 = 0 ;
3728 PyObject * obj1 = 0 ;
3729 char *kwnames[] = {
3730 (char *) "self",(char *) "sz", NULL
3731 };
3732
3733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3735 if (SWIG_arg_fail(1)) SWIG_fail;
3736 {
3737 arg2 = &temp2;
3738 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3739 }
3740 {
3741 PyThreadState* __tstate = wxPyBeginAllowThreads();
3742 (arg1)->DecTo((wxSize const &)*arg2);
3743
3744 wxPyEndAllowThreads(__tstate);
3745 if (PyErr_Occurred()) SWIG_fail;
3746 }
3747 Py_INCREF(Py_None); resultobj = Py_None;
3748 return resultobj;
3749 fail:
3750 return NULL;
3751 }
3752
3753
3754 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3755 PyObject *resultobj;
3756 wxSize *arg1 = (wxSize *) 0 ;
3757 int arg2 ;
3758 int arg3 ;
3759 PyObject * obj0 = 0 ;
3760 PyObject * obj1 = 0 ;
3761 PyObject * obj2 = 0 ;
3762 char *kwnames[] = {
3763 (char *) "self",(char *) "w",(char *) "h", NULL
3764 };
3765
3766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3768 if (SWIG_arg_fail(1)) SWIG_fail;
3769 {
3770 arg2 = (int)(SWIG_As_int(obj1));
3771 if (SWIG_arg_fail(2)) SWIG_fail;
3772 }
3773 {
3774 arg3 = (int)(SWIG_As_int(obj2));
3775 if (SWIG_arg_fail(3)) SWIG_fail;
3776 }
3777 {
3778 PyThreadState* __tstate = wxPyBeginAllowThreads();
3779 (arg1)->Set(arg2,arg3);
3780
3781 wxPyEndAllowThreads(__tstate);
3782 if (PyErr_Occurred()) SWIG_fail;
3783 }
3784 Py_INCREF(Py_None); resultobj = Py_None;
3785 return resultobj;
3786 fail:
3787 return NULL;
3788 }
3789
3790
3791 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3792 PyObject *resultobj;
3793 wxSize *arg1 = (wxSize *) 0 ;
3794 int arg2 ;
3795 PyObject * obj0 = 0 ;
3796 PyObject * obj1 = 0 ;
3797 char *kwnames[] = {
3798 (char *) "self",(char *) "w", NULL
3799 };
3800
3801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3803 if (SWIG_arg_fail(1)) SWIG_fail;
3804 {
3805 arg2 = (int)(SWIG_As_int(obj1));
3806 if (SWIG_arg_fail(2)) SWIG_fail;
3807 }
3808 {
3809 PyThreadState* __tstate = wxPyBeginAllowThreads();
3810 (arg1)->SetWidth(arg2);
3811
3812 wxPyEndAllowThreads(__tstate);
3813 if (PyErr_Occurred()) SWIG_fail;
3814 }
3815 Py_INCREF(Py_None); resultobj = Py_None;
3816 return resultobj;
3817 fail:
3818 return NULL;
3819 }
3820
3821
3822 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3823 PyObject *resultobj;
3824 wxSize *arg1 = (wxSize *) 0 ;
3825 int arg2 ;
3826 PyObject * obj0 = 0 ;
3827 PyObject * obj1 = 0 ;
3828 char *kwnames[] = {
3829 (char *) "self",(char *) "h", NULL
3830 };
3831
3832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3834 if (SWIG_arg_fail(1)) SWIG_fail;
3835 {
3836 arg2 = (int)(SWIG_As_int(obj1));
3837 if (SWIG_arg_fail(2)) SWIG_fail;
3838 }
3839 {
3840 PyThreadState* __tstate = wxPyBeginAllowThreads();
3841 (arg1)->SetHeight(arg2);
3842
3843 wxPyEndAllowThreads(__tstate);
3844 if (PyErr_Occurred()) SWIG_fail;
3845 }
3846 Py_INCREF(Py_None); resultobj = Py_None;
3847 return resultobj;
3848 fail:
3849 return NULL;
3850 }
3851
3852
3853 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3854 PyObject *resultobj;
3855 wxSize *arg1 = (wxSize *) 0 ;
3856 int result;
3857 PyObject * obj0 = 0 ;
3858 char *kwnames[] = {
3859 (char *) "self", NULL
3860 };
3861
3862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3864 if (SWIG_arg_fail(1)) SWIG_fail;
3865 {
3866 PyThreadState* __tstate = wxPyBeginAllowThreads();
3867 result = (int)((wxSize const *)arg1)->GetWidth();
3868
3869 wxPyEndAllowThreads(__tstate);
3870 if (PyErr_Occurred()) SWIG_fail;
3871 }
3872 {
3873 resultobj = SWIG_From_int((int)(result));
3874 }
3875 return resultobj;
3876 fail:
3877 return NULL;
3878 }
3879
3880
3881 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3882 PyObject *resultobj;
3883 wxSize *arg1 = (wxSize *) 0 ;
3884 int result;
3885 PyObject * obj0 = 0 ;
3886 char *kwnames[] = {
3887 (char *) "self", NULL
3888 };
3889
3890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3892 if (SWIG_arg_fail(1)) SWIG_fail;
3893 {
3894 PyThreadState* __tstate = wxPyBeginAllowThreads();
3895 result = (int)((wxSize const *)arg1)->GetHeight();
3896
3897 wxPyEndAllowThreads(__tstate);
3898 if (PyErr_Occurred()) SWIG_fail;
3899 }
3900 {
3901 resultobj = SWIG_From_int((int)(result));
3902 }
3903 return resultobj;
3904 fail:
3905 return NULL;
3906 }
3907
3908
3909 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3910 PyObject *resultobj;
3911 wxSize *arg1 = (wxSize *) 0 ;
3912 bool result;
3913 PyObject * obj0 = 0 ;
3914 char *kwnames[] = {
3915 (char *) "self", NULL
3916 };
3917
3918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3920 if (SWIG_arg_fail(1)) SWIG_fail;
3921 {
3922 PyThreadState* __tstate = wxPyBeginAllowThreads();
3923 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3924
3925 wxPyEndAllowThreads(__tstate);
3926 if (PyErr_Occurred()) SWIG_fail;
3927 }
3928 {
3929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3930 }
3931 return resultobj;
3932 fail:
3933 return NULL;
3934 }
3935
3936
3937 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3938 PyObject *resultobj;
3939 wxSize *arg1 = (wxSize *) 0 ;
3940 wxSize *arg2 = 0 ;
3941 wxSize temp2 ;
3942 PyObject * obj0 = 0 ;
3943 PyObject * obj1 = 0 ;
3944 char *kwnames[] = {
3945 (char *) "self",(char *) "size", NULL
3946 };
3947
3948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3950 if (SWIG_arg_fail(1)) SWIG_fail;
3951 {
3952 arg2 = &temp2;
3953 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3954 }
3955 {
3956 PyThreadState* __tstate = wxPyBeginAllowThreads();
3957 (arg1)->SetDefaults((wxSize const &)*arg2);
3958
3959 wxPyEndAllowThreads(__tstate);
3960 if (PyErr_Occurred()) SWIG_fail;
3961 }
3962 Py_INCREF(Py_None); resultobj = Py_None;
3963 return resultobj;
3964 fail:
3965 return NULL;
3966 }
3967
3968
3969 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3970 PyObject *resultobj;
3971 wxSize *arg1 = (wxSize *) 0 ;
3972 PyObject *result;
3973 PyObject * obj0 = 0 ;
3974 char *kwnames[] = {
3975 (char *) "self", NULL
3976 };
3977
3978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3980 if (SWIG_arg_fail(1)) SWIG_fail;
3981 {
3982 PyThreadState* __tstate = wxPyBeginAllowThreads();
3983 result = (PyObject *)wxSize_Get(arg1);
3984
3985 wxPyEndAllowThreads(__tstate);
3986 if (PyErr_Occurred()) SWIG_fail;
3987 }
3988 resultobj = result;
3989 return resultobj;
3990 fail:
3991 return NULL;
3992 }
3993
3994
3995 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3996 PyObject *obj;
3997 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3998 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3999 Py_INCREF(obj);
4000 return Py_BuildValue((char *)"");
4001 }
4002 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4003 PyObject *resultobj;
4004 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4005 double arg2 ;
4006 PyObject * obj0 = 0 ;
4007 PyObject * obj1 = 0 ;
4008 char *kwnames[] = {
4009 (char *) "self",(char *) "x", NULL
4010 };
4011
4012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4014 if (SWIG_arg_fail(1)) SWIG_fail;
4015 {
4016 arg2 = (double)(SWIG_As_double(obj1));
4017 if (SWIG_arg_fail(2)) SWIG_fail;
4018 }
4019 if (arg1) (arg1)->x = arg2;
4020
4021 Py_INCREF(Py_None); resultobj = Py_None;
4022 return resultobj;
4023 fail:
4024 return NULL;
4025 }
4026
4027
4028 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4029 PyObject *resultobj;
4030 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4031 double result;
4032 PyObject * obj0 = 0 ;
4033 char *kwnames[] = {
4034 (char *) "self", NULL
4035 };
4036
4037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4039 if (SWIG_arg_fail(1)) SWIG_fail;
4040 result = (double) ((arg1)->x);
4041
4042 {
4043 resultobj = SWIG_From_double((double)(result));
4044 }
4045 return resultobj;
4046 fail:
4047 return NULL;
4048 }
4049
4050
4051 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4052 PyObject *resultobj;
4053 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4054 double arg2 ;
4055 PyObject * obj0 = 0 ;
4056 PyObject * obj1 = 0 ;
4057 char *kwnames[] = {
4058 (char *) "self",(char *) "y", NULL
4059 };
4060
4061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4063 if (SWIG_arg_fail(1)) SWIG_fail;
4064 {
4065 arg2 = (double)(SWIG_As_double(obj1));
4066 if (SWIG_arg_fail(2)) SWIG_fail;
4067 }
4068 if (arg1) (arg1)->y = arg2;
4069
4070 Py_INCREF(Py_None); resultobj = Py_None;
4071 return resultobj;
4072 fail:
4073 return NULL;
4074 }
4075
4076
4077 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4078 PyObject *resultobj;
4079 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4080 double result;
4081 PyObject * obj0 = 0 ;
4082 char *kwnames[] = {
4083 (char *) "self", NULL
4084 };
4085
4086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4088 if (SWIG_arg_fail(1)) SWIG_fail;
4089 result = (double) ((arg1)->y);
4090
4091 {
4092 resultobj = SWIG_From_double((double)(result));
4093 }
4094 return resultobj;
4095 fail:
4096 return NULL;
4097 }
4098
4099
4100 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4101 PyObject *resultobj;
4102 double arg1 = (double) 0.0 ;
4103 double arg2 = (double) 0.0 ;
4104 wxRealPoint *result;
4105 PyObject * obj0 = 0 ;
4106 PyObject * obj1 = 0 ;
4107 char *kwnames[] = {
4108 (char *) "x",(char *) "y", NULL
4109 };
4110
4111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4112 if (obj0) {
4113 {
4114 arg1 = (double)(SWIG_As_double(obj0));
4115 if (SWIG_arg_fail(1)) SWIG_fail;
4116 }
4117 }
4118 if (obj1) {
4119 {
4120 arg2 = (double)(SWIG_As_double(obj1));
4121 if (SWIG_arg_fail(2)) SWIG_fail;
4122 }
4123 }
4124 {
4125 PyThreadState* __tstate = wxPyBeginAllowThreads();
4126 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4127
4128 wxPyEndAllowThreads(__tstate);
4129 if (PyErr_Occurred()) SWIG_fail;
4130 }
4131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4132 return resultobj;
4133 fail:
4134 return NULL;
4135 }
4136
4137
4138 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4139 PyObject *resultobj;
4140 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4141 PyObject * obj0 = 0 ;
4142 char *kwnames[] = {
4143 (char *) "self", NULL
4144 };
4145
4146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4148 if (SWIG_arg_fail(1)) SWIG_fail;
4149 {
4150 PyThreadState* __tstate = wxPyBeginAllowThreads();
4151 delete arg1;
4152
4153 wxPyEndAllowThreads(__tstate);
4154 if (PyErr_Occurred()) SWIG_fail;
4155 }
4156 Py_INCREF(Py_None); resultobj = Py_None;
4157 return resultobj;
4158 fail:
4159 return NULL;
4160 }
4161
4162
4163 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4164 PyObject *resultobj;
4165 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4166 wxRealPoint *arg2 = 0 ;
4167 bool result;
4168 wxRealPoint temp2 ;
4169 PyObject * obj0 = 0 ;
4170 PyObject * obj1 = 0 ;
4171 char *kwnames[] = {
4172 (char *) "self",(char *) "pt", NULL
4173 };
4174
4175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4177 if (SWIG_arg_fail(1)) SWIG_fail;
4178 {
4179 arg2 = &temp2;
4180 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4181 }
4182 {
4183 PyThreadState* __tstate = wxPyBeginAllowThreads();
4184 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4185
4186 wxPyEndAllowThreads(__tstate);
4187 if (PyErr_Occurred()) SWIG_fail;
4188 }
4189 {
4190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4191 }
4192 return resultobj;
4193 fail:
4194 return NULL;
4195 }
4196
4197
4198 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4199 PyObject *resultobj;
4200 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4201 wxRealPoint *arg2 = 0 ;
4202 bool result;
4203 wxRealPoint temp2 ;
4204 PyObject * obj0 = 0 ;
4205 PyObject * obj1 = 0 ;
4206 char *kwnames[] = {
4207 (char *) "self",(char *) "pt", NULL
4208 };
4209
4210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4212 if (SWIG_arg_fail(1)) SWIG_fail;
4213 {
4214 arg2 = &temp2;
4215 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4216 }
4217 {
4218 PyThreadState* __tstate = wxPyBeginAllowThreads();
4219 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4220
4221 wxPyEndAllowThreads(__tstate);
4222 if (PyErr_Occurred()) SWIG_fail;
4223 }
4224 {
4225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4226 }
4227 return resultobj;
4228 fail:
4229 return NULL;
4230 }
4231
4232
4233 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4234 PyObject *resultobj;
4235 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4236 wxRealPoint *arg2 = 0 ;
4237 wxRealPoint result;
4238 wxRealPoint temp2 ;
4239 PyObject * obj0 = 0 ;
4240 PyObject * obj1 = 0 ;
4241 char *kwnames[] = {
4242 (char *) "self",(char *) "pt", NULL
4243 };
4244
4245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4247 if (SWIG_arg_fail(1)) SWIG_fail;
4248 {
4249 arg2 = &temp2;
4250 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4251 }
4252 {
4253 PyThreadState* __tstate = wxPyBeginAllowThreads();
4254 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4255
4256 wxPyEndAllowThreads(__tstate);
4257 if (PyErr_Occurred()) SWIG_fail;
4258 }
4259 {
4260 wxRealPoint * resultptr;
4261 resultptr = new wxRealPoint((wxRealPoint &)(result));
4262 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4263 }
4264 return resultobj;
4265 fail:
4266 return NULL;
4267 }
4268
4269
4270 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4271 PyObject *resultobj;
4272 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4273 wxRealPoint *arg2 = 0 ;
4274 wxRealPoint result;
4275 wxRealPoint temp2 ;
4276 PyObject * obj0 = 0 ;
4277 PyObject * obj1 = 0 ;
4278 char *kwnames[] = {
4279 (char *) "self",(char *) "pt", NULL
4280 };
4281
4282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4284 if (SWIG_arg_fail(1)) SWIG_fail;
4285 {
4286 arg2 = &temp2;
4287 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4288 }
4289 {
4290 PyThreadState* __tstate = wxPyBeginAllowThreads();
4291 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4292
4293 wxPyEndAllowThreads(__tstate);
4294 if (PyErr_Occurred()) SWIG_fail;
4295 }
4296 {
4297 wxRealPoint * resultptr;
4298 resultptr = new wxRealPoint((wxRealPoint &)(result));
4299 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4300 }
4301 return resultobj;
4302 fail:
4303 return NULL;
4304 }
4305
4306
4307 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4308 PyObject *resultobj;
4309 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4310 double arg2 ;
4311 double arg3 ;
4312 PyObject * obj0 = 0 ;
4313 PyObject * obj1 = 0 ;
4314 PyObject * obj2 = 0 ;
4315 char *kwnames[] = {
4316 (char *) "self",(char *) "x",(char *) "y", NULL
4317 };
4318
4319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4321 if (SWIG_arg_fail(1)) SWIG_fail;
4322 {
4323 arg2 = (double)(SWIG_As_double(obj1));
4324 if (SWIG_arg_fail(2)) SWIG_fail;
4325 }
4326 {
4327 arg3 = (double)(SWIG_As_double(obj2));
4328 if (SWIG_arg_fail(3)) SWIG_fail;
4329 }
4330 {
4331 PyThreadState* __tstate = wxPyBeginAllowThreads();
4332 wxRealPoint_Set(arg1,arg2,arg3);
4333
4334 wxPyEndAllowThreads(__tstate);
4335 if (PyErr_Occurred()) SWIG_fail;
4336 }
4337 Py_INCREF(Py_None); resultobj = Py_None;
4338 return resultobj;
4339 fail:
4340 return NULL;
4341 }
4342
4343
4344 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4345 PyObject *resultobj;
4346 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4347 PyObject *result;
4348 PyObject * obj0 = 0 ;
4349 char *kwnames[] = {
4350 (char *) "self", NULL
4351 };
4352
4353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4355 if (SWIG_arg_fail(1)) SWIG_fail;
4356 {
4357 PyThreadState* __tstate = wxPyBeginAllowThreads();
4358 result = (PyObject *)wxRealPoint_Get(arg1);
4359
4360 wxPyEndAllowThreads(__tstate);
4361 if (PyErr_Occurred()) SWIG_fail;
4362 }
4363 resultobj = result;
4364 return resultobj;
4365 fail:
4366 return NULL;
4367 }
4368
4369
4370 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4371 PyObject *obj;
4372 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4373 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4374 Py_INCREF(obj);
4375 return Py_BuildValue((char *)"");
4376 }
4377 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4378 PyObject *resultobj;
4379 wxPoint *arg1 = (wxPoint *) 0 ;
4380 int arg2 ;
4381 PyObject * obj0 = 0 ;
4382 PyObject * obj1 = 0 ;
4383 char *kwnames[] = {
4384 (char *) "self",(char *) "x", NULL
4385 };
4386
4387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4389 if (SWIG_arg_fail(1)) SWIG_fail;
4390 {
4391 arg2 = (int)(SWIG_As_int(obj1));
4392 if (SWIG_arg_fail(2)) SWIG_fail;
4393 }
4394 if (arg1) (arg1)->x = arg2;
4395
4396 Py_INCREF(Py_None); resultobj = Py_None;
4397 return resultobj;
4398 fail:
4399 return NULL;
4400 }
4401
4402
4403 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4404 PyObject *resultobj;
4405 wxPoint *arg1 = (wxPoint *) 0 ;
4406 int result;
4407 PyObject * obj0 = 0 ;
4408 char *kwnames[] = {
4409 (char *) "self", NULL
4410 };
4411
4412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4414 if (SWIG_arg_fail(1)) SWIG_fail;
4415 result = (int) ((arg1)->x);
4416
4417 {
4418 resultobj = SWIG_From_int((int)(result));
4419 }
4420 return resultobj;
4421 fail:
4422 return NULL;
4423 }
4424
4425
4426 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4427 PyObject *resultobj;
4428 wxPoint *arg1 = (wxPoint *) 0 ;
4429 int arg2 ;
4430 PyObject * obj0 = 0 ;
4431 PyObject * obj1 = 0 ;
4432 char *kwnames[] = {
4433 (char *) "self",(char *) "y", NULL
4434 };
4435
4436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4438 if (SWIG_arg_fail(1)) SWIG_fail;
4439 {
4440 arg2 = (int)(SWIG_As_int(obj1));
4441 if (SWIG_arg_fail(2)) SWIG_fail;
4442 }
4443 if (arg1) (arg1)->y = arg2;
4444
4445 Py_INCREF(Py_None); resultobj = Py_None;
4446 return resultobj;
4447 fail:
4448 return NULL;
4449 }
4450
4451
4452 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4453 PyObject *resultobj;
4454 wxPoint *arg1 = (wxPoint *) 0 ;
4455 int result;
4456 PyObject * obj0 = 0 ;
4457 char *kwnames[] = {
4458 (char *) "self", NULL
4459 };
4460
4461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4463 if (SWIG_arg_fail(1)) SWIG_fail;
4464 result = (int) ((arg1)->y);
4465
4466 {
4467 resultobj = SWIG_From_int((int)(result));
4468 }
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4476 PyObject *resultobj;
4477 int arg1 = (int) 0 ;
4478 int arg2 = (int) 0 ;
4479 wxPoint *result;
4480 PyObject * obj0 = 0 ;
4481 PyObject * obj1 = 0 ;
4482 char *kwnames[] = {
4483 (char *) "x",(char *) "y", NULL
4484 };
4485
4486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4487 if (obj0) {
4488 {
4489 arg1 = (int)(SWIG_As_int(obj0));
4490 if (SWIG_arg_fail(1)) SWIG_fail;
4491 }
4492 }
4493 if (obj1) {
4494 {
4495 arg2 = (int)(SWIG_As_int(obj1));
4496 if (SWIG_arg_fail(2)) SWIG_fail;
4497 }
4498 }
4499 {
4500 PyThreadState* __tstate = wxPyBeginAllowThreads();
4501 result = (wxPoint *)new wxPoint(arg1,arg2);
4502
4503 wxPyEndAllowThreads(__tstate);
4504 if (PyErr_Occurred()) SWIG_fail;
4505 }
4506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4507 return resultobj;
4508 fail:
4509 return NULL;
4510 }
4511
4512
4513 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4514 PyObject *resultobj;
4515 wxPoint *arg1 = (wxPoint *) 0 ;
4516 PyObject * obj0 = 0 ;
4517 char *kwnames[] = {
4518 (char *) "self", NULL
4519 };
4520
4521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4523 if (SWIG_arg_fail(1)) SWIG_fail;
4524 {
4525 PyThreadState* __tstate = wxPyBeginAllowThreads();
4526 delete arg1;
4527
4528 wxPyEndAllowThreads(__tstate);
4529 if (PyErr_Occurred()) SWIG_fail;
4530 }
4531 Py_INCREF(Py_None); resultobj = Py_None;
4532 return resultobj;
4533 fail:
4534 return NULL;
4535 }
4536
4537
4538 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4539 PyObject *resultobj;
4540 wxPoint *arg1 = (wxPoint *) 0 ;
4541 wxPoint *arg2 = 0 ;
4542 bool result;
4543 wxPoint temp2 ;
4544 PyObject * obj0 = 0 ;
4545 PyObject * obj1 = 0 ;
4546 char *kwnames[] = {
4547 (char *) "self",(char *) "pt", NULL
4548 };
4549
4550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4552 if (SWIG_arg_fail(1)) SWIG_fail;
4553 {
4554 arg2 = &temp2;
4555 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4556 }
4557 {
4558 PyThreadState* __tstate = wxPyBeginAllowThreads();
4559 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4560
4561 wxPyEndAllowThreads(__tstate);
4562 if (PyErr_Occurred()) SWIG_fail;
4563 }
4564 {
4565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4566 }
4567 return resultobj;
4568 fail:
4569 return NULL;
4570 }
4571
4572
4573 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4574 PyObject *resultobj;
4575 wxPoint *arg1 = (wxPoint *) 0 ;
4576 wxPoint *arg2 = 0 ;
4577 bool result;
4578 wxPoint temp2 ;
4579 PyObject * obj0 = 0 ;
4580 PyObject * obj1 = 0 ;
4581 char *kwnames[] = {
4582 (char *) "self",(char *) "pt", NULL
4583 };
4584
4585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4587 if (SWIG_arg_fail(1)) SWIG_fail;
4588 {
4589 arg2 = &temp2;
4590 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4591 }
4592 {
4593 PyThreadState* __tstate = wxPyBeginAllowThreads();
4594 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4595
4596 wxPyEndAllowThreads(__tstate);
4597 if (PyErr_Occurred()) SWIG_fail;
4598 }
4599 {
4600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4601 }
4602 return resultobj;
4603 fail:
4604 return NULL;
4605 }
4606
4607
4608 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4609 PyObject *resultobj;
4610 wxPoint *arg1 = (wxPoint *) 0 ;
4611 wxPoint *arg2 = 0 ;
4612 wxPoint result;
4613 wxPoint temp2 ;
4614 PyObject * obj0 = 0 ;
4615 PyObject * obj1 = 0 ;
4616 char *kwnames[] = {
4617 (char *) "self",(char *) "pt", NULL
4618 };
4619
4620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4622 if (SWIG_arg_fail(1)) SWIG_fail;
4623 {
4624 arg2 = &temp2;
4625 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4626 }
4627 {
4628 PyThreadState* __tstate = wxPyBeginAllowThreads();
4629 result = (arg1)->operator +((wxPoint const &)*arg2);
4630
4631 wxPyEndAllowThreads(__tstate);
4632 if (PyErr_Occurred()) SWIG_fail;
4633 }
4634 {
4635 wxPoint * resultptr;
4636 resultptr = new wxPoint((wxPoint &)(result));
4637 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4638 }
4639 return resultobj;
4640 fail:
4641 return NULL;
4642 }
4643
4644
4645 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4646 PyObject *resultobj;
4647 wxPoint *arg1 = (wxPoint *) 0 ;
4648 wxPoint *arg2 = 0 ;
4649 wxPoint result;
4650 wxPoint temp2 ;
4651 PyObject * obj0 = 0 ;
4652 PyObject * obj1 = 0 ;
4653 char *kwnames[] = {
4654 (char *) "self",(char *) "pt", NULL
4655 };
4656
4657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4659 if (SWIG_arg_fail(1)) SWIG_fail;
4660 {
4661 arg2 = &temp2;
4662 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4663 }
4664 {
4665 PyThreadState* __tstate = wxPyBeginAllowThreads();
4666 result = (arg1)->operator -((wxPoint const &)*arg2);
4667
4668 wxPyEndAllowThreads(__tstate);
4669 if (PyErr_Occurred()) SWIG_fail;
4670 }
4671 {
4672 wxPoint * resultptr;
4673 resultptr = new wxPoint((wxPoint &)(result));
4674 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4675 }
4676 return resultobj;
4677 fail:
4678 return NULL;
4679 }
4680
4681
4682 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4683 PyObject *resultobj;
4684 wxPoint *arg1 = (wxPoint *) 0 ;
4685 wxPoint *arg2 = 0 ;
4686 wxPoint *result;
4687 wxPoint temp2 ;
4688 PyObject * obj0 = 0 ;
4689 PyObject * obj1 = 0 ;
4690 char *kwnames[] = {
4691 (char *) "self",(char *) "pt", NULL
4692 };
4693
4694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4696 if (SWIG_arg_fail(1)) SWIG_fail;
4697 {
4698 arg2 = &temp2;
4699 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4700 }
4701 {
4702 PyThreadState* __tstate = wxPyBeginAllowThreads();
4703 {
4704 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4705 result = (wxPoint *) &_result_ref;
4706 }
4707
4708 wxPyEndAllowThreads(__tstate);
4709 if (PyErr_Occurred()) SWIG_fail;
4710 }
4711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4712 return resultobj;
4713 fail:
4714 return NULL;
4715 }
4716
4717
4718 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4719 PyObject *resultobj;
4720 wxPoint *arg1 = (wxPoint *) 0 ;
4721 wxPoint *arg2 = 0 ;
4722 wxPoint *result;
4723 wxPoint temp2 ;
4724 PyObject * obj0 = 0 ;
4725 PyObject * obj1 = 0 ;
4726 char *kwnames[] = {
4727 (char *) "self",(char *) "pt", NULL
4728 };
4729
4730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4732 if (SWIG_arg_fail(1)) SWIG_fail;
4733 {
4734 arg2 = &temp2;
4735 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4736 }
4737 {
4738 PyThreadState* __tstate = wxPyBeginAllowThreads();
4739 {
4740 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4741 result = (wxPoint *) &_result_ref;
4742 }
4743
4744 wxPyEndAllowThreads(__tstate);
4745 if (PyErr_Occurred()) SWIG_fail;
4746 }
4747 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4748 return resultobj;
4749 fail:
4750 return NULL;
4751 }
4752
4753
4754 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4755 PyObject *resultobj;
4756 wxPoint *arg1 = (wxPoint *) 0 ;
4757 long arg2 ;
4758 long arg3 ;
4759 PyObject * obj0 = 0 ;
4760 PyObject * obj1 = 0 ;
4761 PyObject * obj2 = 0 ;
4762 char *kwnames[] = {
4763 (char *) "self",(char *) "x",(char *) "y", NULL
4764 };
4765
4766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4768 if (SWIG_arg_fail(1)) SWIG_fail;
4769 {
4770 arg2 = (long)(SWIG_As_long(obj1));
4771 if (SWIG_arg_fail(2)) SWIG_fail;
4772 }
4773 {
4774 arg3 = (long)(SWIG_As_long(obj2));
4775 if (SWIG_arg_fail(3)) SWIG_fail;
4776 }
4777 {
4778 PyThreadState* __tstate = wxPyBeginAllowThreads();
4779 wxPoint_Set(arg1,arg2,arg3);
4780
4781 wxPyEndAllowThreads(__tstate);
4782 if (PyErr_Occurred()) SWIG_fail;
4783 }
4784 Py_INCREF(Py_None); resultobj = Py_None;
4785 return resultobj;
4786 fail:
4787 return NULL;
4788 }
4789
4790
4791 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4792 PyObject *resultobj;
4793 wxPoint *arg1 = (wxPoint *) 0 ;
4794 PyObject *result;
4795 PyObject * obj0 = 0 ;
4796 char *kwnames[] = {
4797 (char *) "self", NULL
4798 };
4799
4800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4802 if (SWIG_arg_fail(1)) SWIG_fail;
4803 {
4804 PyThreadState* __tstate = wxPyBeginAllowThreads();
4805 result = (PyObject *)wxPoint_Get(arg1);
4806
4807 wxPyEndAllowThreads(__tstate);
4808 if (PyErr_Occurred()) SWIG_fail;
4809 }
4810 resultobj = result;
4811 return resultobj;
4812 fail:
4813 return NULL;
4814 }
4815
4816
4817 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4818 PyObject *obj;
4819 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4820 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4821 Py_INCREF(obj);
4822 return Py_BuildValue((char *)"");
4823 }
4824 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4825 PyObject *resultobj;
4826 int arg1 = (int) 0 ;
4827 int arg2 = (int) 0 ;
4828 int arg3 = (int) 0 ;
4829 int arg4 = (int) 0 ;
4830 wxRect *result;
4831 PyObject * obj0 = 0 ;
4832 PyObject * obj1 = 0 ;
4833 PyObject * obj2 = 0 ;
4834 PyObject * obj3 = 0 ;
4835 char *kwnames[] = {
4836 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4837 };
4838
4839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4840 if (obj0) {
4841 {
4842 arg1 = (int)(SWIG_As_int(obj0));
4843 if (SWIG_arg_fail(1)) SWIG_fail;
4844 }
4845 }
4846 if (obj1) {
4847 {
4848 arg2 = (int)(SWIG_As_int(obj1));
4849 if (SWIG_arg_fail(2)) SWIG_fail;
4850 }
4851 }
4852 if (obj2) {
4853 {
4854 arg3 = (int)(SWIG_As_int(obj2));
4855 if (SWIG_arg_fail(3)) SWIG_fail;
4856 }
4857 }
4858 if (obj3) {
4859 {
4860 arg4 = (int)(SWIG_As_int(obj3));
4861 if (SWIG_arg_fail(4)) SWIG_fail;
4862 }
4863 }
4864 {
4865 PyThreadState* __tstate = wxPyBeginAllowThreads();
4866 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4867
4868 wxPyEndAllowThreads(__tstate);
4869 if (PyErr_Occurred()) SWIG_fail;
4870 }
4871 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4872 return resultobj;
4873 fail:
4874 return NULL;
4875 }
4876
4877
4878 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4879 PyObject *resultobj;
4880 wxPoint *arg1 = 0 ;
4881 wxPoint *arg2 = 0 ;
4882 wxRect *result;
4883 wxPoint temp1 ;
4884 wxPoint temp2 ;
4885 PyObject * obj0 = 0 ;
4886 PyObject * obj1 = 0 ;
4887 char *kwnames[] = {
4888 (char *) "topLeft",(char *) "bottomRight", NULL
4889 };
4890
4891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4892 {
4893 arg1 = &temp1;
4894 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4895 }
4896 {
4897 arg2 = &temp2;
4898 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4899 }
4900 {
4901 PyThreadState* __tstate = wxPyBeginAllowThreads();
4902 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4903
4904 wxPyEndAllowThreads(__tstate);
4905 if (PyErr_Occurred()) SWIG_fail;
4906 }
4907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4908 return resultobj;
4909 fail:
4910 return NULL;
4911 }
4912
4913
4914 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4915 PyObject *resultobj;
4916 wxPoint *arg1 = 0 ;
4917 wxSize *arg2 = 0 ;
4918 wxRect *result;
4919 wxPoint temp1 ;
4920 wxSize temp2 ;
4921 PyObject * obj0 = 0 ;
4922 PyObject * obj1 = 0 ;
4923 char *kwnames[] = {
4924 (char *) "pos",(char *) "size", NULL
4925 };
4926
4927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4928 {
4929 arg1 = &temp1;
4930 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4931 }
4932 {
4933 arg2 = &temp2;
4934 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4935 }
4936 {
4937 PyThreadState* __tstate = wxPyBeginAllowThreads();
4938 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4939
4940 wxPyEndAllowThreads(__tstate);
4941 if (PyErr_Occurred()) SWIG_fail;
4942 }
4943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4944 return resultobj;
4945 fail:
4946 return NULL;
4947 }
4948
4949
4950 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4951 PyObject *resultobj;
4952 wxSize *arg1 = 0 ;
4953 wxRect *result;
4954 wxSize temp1 ;
4955 PyObject * obj0 = 0 ;
4956 char *kwnames[] = {
4957 (char *) "size", NULL
4958 };
4959
4960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4961 {
4962 arg1 = &temp1;
4963 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4964 }
4965 {
4966 PyThreadState* __tstate = wxPyBeginAllowThreads();
4967 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4968
4969 wxPyEndAllowThreads(__tstate);
4970 if (PyErr_Occurred()) SWIG_fail;
4971 }
4972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4973 return resultobj;
4974 fail:
4975 return NULL;
4976 }
4977
4978
4979 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4980 PyObject *resultobj;
4981 wxRect *arg1 = (wxRect *) 0 ;
4982 PyObject * obj0 = 0 ;
4983 char *kwnames[] = {
4984 (char *) "self", NULL
4985 };
4986
4987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4989 if (SWIG_arg_fail(1)) SWIG_fail;
4990 {
4991 PyThreadState* __tstate = wxPyBeginAllowThreads();
4992 delete arg1;
4993
4994 wxPyEndAllowThreads(__tstate);
4995 if (PyErr_Occurred()) SWIG_fail;
4996 }
4997 Py_INCREF(Py_None); resultobj = Py_None;
4998 return resultobj;
4999 fail:
5000 return NULL;
5001 }
5002
5003
5004 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
5005 PyObject *resultobj;
5006 wxRect *arg1 = (wxRect *) 0 ;
5007 int result;
5008 PyObject * obj0 = 0 ;
5009 char *kwnames[] = {
5010 (char *) "self", NULL
5011 };
5012
5013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
5014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5015 if (SWIG_arg_fail(1)) SWIG_fail;
5016 {
5017 PyThreadState* __tstate = wxPyBeginAllowThreads();
5018 result = (int)((wxRect const *)arg1)->GetX();
5019
5020 wxPyEndAllowThreads(__tstate);
5021 if (PyErr_Occurred()) SWIG_fail;
5022 }
5023 {
5024 resultobj = SWIG_From_int((int)(result));
5025 }
5026 return resultobj;
5027 fail:
5028 return NULL;
5029 }
5030
5031
5032 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5033 PyObject *resultobj;
5034 wxRect *arg1 = (wxRect *) 0 ;
5035 int arg2 ;
5036 PyObject * obj0 = 0 ;
5037 PyObject * obj1 = 0 ;
5038 char *kwnames[] = {
5039 (char *) "self",(char *) "x", NULL
5040 };
5041
5042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5044 if (SWIG_arg_fail(1)) SWIG_fail;
5045 {
5046 arg2 = (int)(SWIG_As_int(obj1));
5047 if (SWIG_arg_fail(2)) SWIG_fail;
5048 }
5049 {
5050 PyThreadState* __tstate = wxPyBeginAllowThreads();
5051 (arg1)->SetX(arg2);
5052
5053 wxPyEndAllowThreads(__tstate);
5054 if (PyErr_Occurred()) SWIG_fail;
5055 }
5056 Py_INCREF(Py_None); resultobj = Py_None;
5057 return resultobj;
5058 fail:
5059 return NULL;
5060 }
5061
5062
5063 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5064 PyObject *resultobj;
5065 wxRect *arg1 = (wxRect *) 0 ;
5066 int result;
5067 PyObject * obj0 = 0 ;
5068 char *kwnames[] = {
5069 (char *) "self", NULL
5070 };
5071
5072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5074 if (SWIG_arg_fail(1)) SWIG_fail;
5075 {
5076 PyThreadState* __tstate = wxPyBeginAllowThreads();
5077 result = (int)(arg1)->GetY();
5078
5079 wxPyEndAllowThreads(__tstate);
5080 if (PyErr_Occurred()) SWIG_fail;
5081 }
5082 {
5083 resultobj = SWIG_From_int((int)(result));
5084 }
5085 return resultobj;
5086 fail:
5087 return NULL;
5088 }
5089
5090
5091 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5092 PyObject *resultobj;
5093 wxRect *arg1 = (wxRect *) 0 ;
5094 int arg2 ;
5095 PyObject * obj0 = 0 ;
5096 PyObject * obj1 = 0 ;
5097 char *kwnames[] = {
5098 (char *) "self",(char *) "y", NULL
5099 };
5100
5101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5103 if (SWIG_arg_fail(1)) SWIG_fail;
5104 {
5105 arg2 = (int)(SWIG_As_int(obj1));
5106 if (SWIG_arg_fail(2)) SWIG_fail;
5107 }
5108 {
5109 PyThreadState* __tstate = wxPyBeginAllowThreads();
5110 (arg1)->SetY(arg2);
5111
5112 wxPyEndAllowThreads(__tstate);
5113 if (PyErr_Occurred()) SWIG_fail;
5114 }
5115 Py_INCREF(Py_None); resultobj = Py_None;
5116 return resultobj;
5117 fail:
5118 return NULL;
5119 }
5120
5121
5122 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5123 PyObject *resultobj;
5124 wxRect *arg1 = (wxRect *) 0 ;
5125 int result;
5126 PyObject * obj0 = 0 ;
5127 char *kwnames[] = {
5128 (char *) "self", NULL
5129 };
5130
5131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5133 if (SWIG_arg_fail(1)) SWIG_fail;
5134 {
5135 PyThreadState* __tstate = wxPyBeginAllowThreads();
5136 result = (int)((wxRect const *)arg1)->GetWidth();
5137
5138 wxPyEndAllowThreads(__tstate);
5139 if (PyErr_Occurred()) SWIG_fail;
5140 }
5141 {
5142 resultobj = SWIG_From_int((int)(result));
5143 }
5144 return resultobj;
5145 fail:
5146 return NULL;
5147 }
5148
5149
5150 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5151 PyObject *resultobj;
5152 wxRect *arg1 = (wxRect *) 0 ;
5153 int arg2 ;
5154 PyObject * obj0 = 0 ;
5155 PyObject * obj1 = 0 ;
5156 char *kwnames[] = {
5157 (char *) "self",(char *) "w", NULL
5158 };
5159
5160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5162 if (SWIG_arg_fail(1)) SWIG_fail;
5163 {
5164 arg2 = (int)(SWIG_As_int(obj1));
5165 if (SWIG_arg_fail(2)) SWIG_fail;
5166 }
5167 {
5168 PyThreadState* __tstate = wxPyBeginAllowThreads();
5169 (arg1)->SetWidth(arg2);
5170
5171 wxPyEndAllowThreads(__tstate);
5172 if (PyErr_Occurred()) SWIG_fail;
5173 }
5174 Py_INCREF(Py_None); resultobj = Py_None;
5175 return resultobj;
5176 fail:
5177 return NULL;
5178 }
5179
5180
5181 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5182 PyObject *resultobj;
5183 wxRect *arg1 = (wxRect *) 0 ;
5184 int result;
5185 PyObject * obj0 = 0 ;
5186 char *kwnames[] = {
5187 (char *) "self", NULL
5188 };
5189
5190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5192 if (SWIG_arg_fail(1)) SWIG_fail;
5193 {
5194 PyThreadState* __tstate = wxPyBeginAllowThreads();
5195 result = (int)((wxRect const *)arg1)->GetHeight();
5196
5197 wxPyEndAllowThreads(__tstate);
5198 if (PyErr_Occurred()) SWIG_fail;
5199 }
5200 {
5201 resultobj = SWIG_From_int((int)(result));
5202 }
5203 return resultobj;
5204 fail:
5205 return NULL;
5206 }
5207
5208
5209 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5210 PyObject *resultobj;
5211 wxRect *arg1 = (wxRect *) 0 ;
5212 int arg2 ;
5213 PyObject * obj0 = 0 ;
5214 PyObject * obj1 = 0 ;
5215 char *kwnames[] = {
5216 (char *) "self",(char *) "h", NULL
5217 };
5218
5219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5221 if (SWIG_arg_fail(1)) SWIG_fail;
5222 {
5223 arg2 = (int)(SWIG_As_int(obj1));
5224 if (SWIG_arg_fail(2)) SWIG_fail;
5225 }
5226 {
5227 PyThreadState* __tstate = wxPyBeginAllowThreads();
5228 (arg1)->SetHeight(arg2);
5229
5230 wxPyEndAllowThreads(__tstate);
5231 if (PyErr_Occurred()) SWIG_fail;
5232 }
5233 Py_INCREF(Py_None); resultobj = Py_None;
5234 return resultobj;
5235 fail:
5236 return NULL;
5237 }
5238
5239
5240 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5241 PyObject *resultobj;
5242 wxRect *arg1 = (wxRect *) 0 ;
5243 wxPoint result;
5244 PyObject * obj0 = 0 ;
5245 char *kwnames[] = {
5246 (char *) "self", NULL
5247 };
5248
5249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5251 if (SWIG_arg_fail(1)) SWIG_fail;
5252 {
5253 PyThreadState* __tstate = wxPyBeginAllowThreads();
5254 result = ((wxRect const *)arg1)->GetPosition();
5255
5256 wxPyEndAllowThreads(__tstate);
5257 if (PyErr_Occurred()) SWIG_fail;
5258 }
5259 {
5260 wxPoint * resultptr;
5261 resultptr = new wxPoint((wxPoint &)(result));
5262 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5263 }
5264 return resultobj;
5265 fail:
5266 return NULL;
5267 }
5268
5269
5270 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5271 PyObject *resultobj;
5272 wxRect *arg1 = (wxRect *) 0 ;
5273 wxPoint *arg2 = 0 ;
5274 wxPoint temp2 ;
5275 PyObject * obj0 = 0 ;
5276 PyObject * obj1 = 0 ;
5277 char *kwnames[] = {
5278 (char *) "self",(char *) "p", NULL
5279 };
5280
5281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5283 if (SWIG_arg_fail(1)) SWIG_fail;
5284 {
5285 arg2 = &temp2;
5286 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5287 }
5288 {
5289 PyThreadState* __tstate = wxPyBeginAllowThreads();
5290 (arg1)->SetPosition((wxPoint const &)*arg2);
5291
5292 wxPyEndAllowThreads(__tstate);
5293 if (PyErr_Occurred()) SWIG_fail;
5294 }
5295 Py_INCREF(Py_None); resultobj = Py_None;
5296 return resultobj;
5297 fail:
5298 return NULL;
5299 }
5300
5301
5302 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5303 PyObject *resultobj;
5304 wxRect *arg1 = (wxRect *) 0 ;
5305 wxSize result;
5306 PyObject * obj0 = 0 ;
5307 char *kwnames[] = {
5308 (char *) "self", NULL
5309 };
5310
5311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5313 if (SWIG_arg_fail(1)) SWIG_fail;
5314 {
5315 PyThreadState* __tstate = wxPyBeginAllowThreads();
5316 result = ((wxRect const *)arg1)->GetSize();
5317
5318 wxPyEndAllowThreads(__tstate);
5319 if (PyErr_Occurred()) SWIG_fail;
5320 }
5321 {
5322 wxSize * resultptr;
5323 resultptr = new wxSize((wxSize &)(result));
5324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5325 }
5326 return resultobj;
5327 fail:
5328 return NULL;
5329 }
5330
5331
5332 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5333 PyObject *resultobj;
5334 wxRect *arg1 = (wxRect *) 0 ;
5335 wxSize *arg2 = 0 ;
5336 wxSize temp2 ;
5337 PyObject * obj0 = 0 ;
5338 PyObject * obj1 = 0 ;
5339 char *kwnames[] = {
5340 (char *) "self",(char *) "s", NULL
5341 };
5342
5343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5345 if (SWIG_arg_fail(1)) SWIG_fail;
5346 {
5347 arg2 = &temp2;
5348 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5349 }
5350 {
5351 PyThreadState* __tstate = wxPyBeginAllowThreads();
5352 (arg1)->SetSize((wxSize const &)*arg2);
5353
5354 wxPyEndAllowThreads(__tstate);
5355 if (PyErr_Occurred()) SWIG_fail;
5356 }
5357 Py_INCREF(Py_None); resultobj = Py_None;
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5365 PyObject *resultobj;
5366 wxRect *arg1 = (wxRect *) 0 ;
5367 bool result;
5368 PyObject * obj0 = 0 ;
5369 char *kwnames[] = {
5370 (char *) "self", NULL
5371 };
5372
5373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5375 if (SWIG_arg_fail(1)) SWIG_fail;
5376 {
5377 PyThreadState* __tstate = wxPyBeginAllowThreads();
5378 result = (bool)((wxRect const *)arg1)->IsEmpty();
5379
5380 wxPyEndAllowThreads(__tstate);
5381 if (PyErr_Occurred()) SWIG_fail;
5382 }
5383 {
5384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5385 }
5386 return resultobj;
5387 fail:
5388 return NULL;
5389 }
5390
5391
5392 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5393 PyObject *resultobj;
5394 wxRect *arg1 = (wxRect *) 0 ;
5395 wxPoint result;
5396 PyObject * obj0 = 0 ;
5397 char *kwnames[] = {
5398 (char *) "self", NULL
5399 };
5400
5401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5403 if (SWIG_arg_fail(1)) SWIG_fail;
5404 {
5405 PyThreadState* __tstate = wxPyBeginAllowThreads();
5406 result = ((wxRect const *)arg1)->GetTopLeft();
5407
5408 wxPyEndAllowThreads(__tstate);
5409 if (PyErr_Occurred()) SWIG_fail;
5410 }
5411 {
5412 wxPoint * resultptr;
5413 resultptr = new wxPoint((wxPoint &)(result));
5414 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5415 }
5416 return resultobj;
5417 fail:
5418 return NULL;
5419 }
5420
5421
5422 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5423 PyObject *resultobj;
5424 wxRect *arg1 = (wxRect *) 0 ;
5425 wxPoint *arg2 = 0 ;
5426 wxPoint temp2 ;
5427 PyObject * obj0 = 0 ;
5428 PyObject * obj1 = 0 ;
5429 char *kwnames[] = {
5430 (char *) "self",(char *) "p", NULL
5431 };
5432
5433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5435 if (SWIG_arg_fail(1)) SWIG_fail;
5436 {
5437 arg2 = &temp2;
5438 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5439 }
5440 {
5441 PyThreadState* __tstate = wxPyBeginAllowThreads();
5442 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5443
5444 wxPyEndAllowThreads(__tstate);
5445 if (PyErr_Occurred()) SWIG_fail;
5446 }
5447 Py_INCREF(Py_None); resultobj = Py_None;
5448 return resultobj;
5449 fail:
5450 return NULL;
5451 }
5452
5453
5454 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5455 PyObject *resultobj;
5456 wxRect *arg1 = (wxRect *) 0 ;
5457 wxPoint result;
5458 PyObject * obj0 = 0 ;
5459 char *kwnames[] = {
5460 (char *) "self", NULL
5461 };
5462
5463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5465 if (SWIG_arg_fail(1)) SWIG_fail;
5466 {
5467 PyThreadState* __tstate = wxPyBeginAllowThreads();
5468 result = ((wxRect const *)arg1)->GetBottomRight();
5469
5470 wxPyEndAllowThreads(__tstate);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 {
5474 wxPoint * resultptr;
5475 resultptr = new wxPoint((wxPoint &)(result));
5476 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5477 }
5478 return resultobj;
5479 fail:
5480 return NULL;
5481 }
5482
5483
5484 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5485 PyObject *resultobj;
5486 wxRect *arg1 = (wxRect *) 0 ;
5487 wxPoint *arg2 = 0 ;
5488 wxPoint temp2 ;
5489 PyObject * obj0 = 0 ;
5490 PyObject * obj1 = 0 ;
5491 char *kwnames[] = {
5492 (char *) "self",(char *) "p", NULL
5493 };
5494
5495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5497 if (SWIG_arg_fail(1)) SWIG_fail;
5498 {
5499 arg2 = &temp2;
5500 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5501 }
5502 {
5503 PyThreadState* __tstate = wxPyBeginAllowThreads();
5504 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5505
5506 wxPyEndAllowThreads(__tstate);
5507 if (PyErr_Occurred()) SWIG_fail;
5508 }
5509 Py_INCREF(Py_None); resultobj = Py_None;
5510 return resultobj;
5511 fail:
5512 return NULL;
5513 }
5514
5515
5516 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5517 PyObject *resultobj;
5518 wxRect *arg1 = (wxRect *) 0 ;
5519 int result;
5520 PyObject * obj0 = 0 ;
5521 char *kwnames[] = {
5522 (char *) "self", NULL
5523 };
5524
5525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5527 if (SWIG_arg_fail(1)) SWIG_fail;
5528 {
5529 PyThreadState* __tstate = wxPyBeginAllowThreads();
5530 result = (int)((wxRect const *)arg1)->GetLeft();
5531
5532 wxPyEndAllowThreads(__tstate);
5533 if (PyErr_Occurred()) SWIG_fail;
5534 }
5535 {
5536 resultobj = SWIG_From_int((int)(result));
5537 }
5538 return resultobj;
5539 fail:
5540 return NULL;
5541 }
5542
5543
5544 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5545 PyObject *resultobj;
5546 wxRect *arg1 = (wxRect *) 0 ;
5547 int result;
5548 PyObject * obj0 = 0 ;
5549 char *kwnames[] = {
5550 (char *) "self", NULL
5551 };
5552
5553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5555 if (SWIG_arg_fail(1)) SWIG_fail;
5556 {
5557 PyThreadState* __tstate = wxPyBeginAllowThreads();
5558 result = (int)((wxRect const *)arg1)->GetTop();
5559
5560 wxPyEndAllowThreads(__tstate);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 {
5564 resultobj = SWIG_From_int((int)(result));
5565 }
5566 return resultobj;
5567 fail:
5568 return NULL;
5569 }
5570
5571
5572 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5573 PyObject *resultobj;
5574 wxRect *arg1 = (wxRect *) 0 ;
5575 int result;
5576 PyObject * obj0 = 0 ;
5577 char *kwnames[] = {
5578 (char *) "self", NULL
5579 };
5580
5581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5583 if (SWIG_arg_fail(1)) SWIG_fail;
5584 {
5585 PyThreadState* __tstate = wxPyBeginAllowThreads();
5586 result = (int)((wxRect const *)arg1)->GetBottom();
5587
5588 wxPyEndAllowThreads(__tstate);
5589 if (PyErr_Occurred()) SWIG_fail;
5590 }
5591 {
5592 resultobj = SWIG_From_int((int)(result));
5593 }
5594 return resultobj;
5595 fail:
5596 return NULL;
5597 }
5598
5599
5600 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5601 PyObject *resultobj;
5602 wxRect *arg1 = (wxRect *) 0 ;
5603 int result;
5604 PyObject * obj0 = 0 ;
5605 char *kwnames[] = {
5606 (char *) "self", NULL
5607 };
5608
5609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5611 if (SWIG_arg_fail(1)) SWIG_fail;
5612 {
5613 PyThreadState* __tstate = wxPyBeginAllowThreads();
5614 result = (int)((wxRect const *)arg1)->GetRight();
5615
5616 wxPyEndAllowThreads(__tstate);
5617 if (PyErr_Occurred()) SWIG_fail;
5618 }
5619 {
5620 resultobj = SWIG_From_int((int)(result));
5621 }
5622 return resultobj;
5623 fail:
5624 return NULL;
5625 }
5626
5627
5628 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5629 PyObject *resultobj;
5630 wxRect *arg1 = (wxRect *) 0 ;
5631 int arg2 ;
5632 PyObject * obj0 = 0 ;
5633 PyObject * obj1 = 0 ;
5634 char *kwnames[] = {
5635 (char *) "self",(char *) "left", NULL
5636 };
5637
5638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5640 if (SWIG_arg_fail(1)) SWIG_fail;
5641 {
5642 arg2 = (int)(SWIG_As_int(obj1));
5643 if (SWIG_arg_fail(2)) SWIG_fail;
5644 }
5645 {
5646 PyThreadState* __tstate = wxPyBeginAllowThreads();
5647 (arg1)->SetLeft(arg2);
5648
5649 wxPyEndAllowThreads(__tstate);
5650 if (PyErr_Occurred()) SWIG_fail;
5651 }
5652 Py_INCREF(Py_None); resultobj = Py_None;
5653 return resultobj;
5654 fail:
5655 return NULL;
5656 }
5657
5658
5659 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5660 PyObject *resultobj;
5661 wxRect *arg1 = (wxRect *) 0 ;
5662 int arg2 ;
5663 PyObject * obj0 = 0 ;
5664 PyObject * obj1 = 0 ;
5665 char *kwnames[] = {
5666 (char *) "self",(char *) "right", NULL
5667 };
5668
5669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5671 if (SWIG_arg_fail(1)) SWIG_fail;
5672 {
5673 arg2 = (int)(SWIG_As_int(obj1));
5674 if (SWIG_arg_fail(2)) SWIG_fail;
5675 }
5676 {
5677 PyThreadState* __tstate = wxPyBeginAllowThreads();
5678 (arg1)->SetRight(arg2);
5679
5680 wxPyEndAllowThreads(__tstate);
5681 if (PyErr_Occurred()) SWIG_fail;
5682 }
5683 Py_INCREF(Py_None); resultobj = Py_None;
5684 return resultobj;
5685 fail:
5686 return NULL;
5687 }
5688
5689
5690 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5691 PyObject *resultobj;
5692 wxRect *arg1 = (wxRect *) 0 ;
5693 int arg2 ;
5694 PyObject * obj0 = 0 ;
5695 PyObject * obj1 = 0 ;
5696 char *kwnames[] = {
5697 (char *) "self",(char *) "top", NULL
5698 };
5699
5700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5702 if (SWIG_arg_fail(1)) SWIG_fail;
5703 {
5704 arg2 = (int)(SWIG_As_int(obj1));
5705 if (SWIG_arg_fail(2)) SWIG_fail;
5706 }
5707 {
5708 PyThreadState* __tstate = wxPyBeginAllowThreads();
5709 (arg1)->SetTop(arg2);
5710
5711 wxPyEndAllowThreads(__tstate);
5712 if (PyErr_Occurred()) SWIG_fail;
5713 }
5714 Py_INCREF(Py_None); resultobj = Py_None;
5715 return resultobj;
5716 fail:
5717 return NULL;
5718 }
5719
5720
5721 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5722 PyObject *resultobj;
5723 wxRect *arg1 = (wxRect *) 0 ;
5724 int arg2 ;
5725 PyObject * obj0 = 0 ;
5726 PyObject * obj1 = 0 ;
5727 char *kwnames[] = {
5728 (char *) "self",(char *) "bottom", NULL
5729 };
5730
5731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5733 if (SWIG_arg_fail(1)) SWIG_fail;
5734 {
5735 arg2 = (int)(SWIG_As_int(obj1));
5736 if (SWIG_arg_fail(2)) SWIG_fail;
5737 }
5738 {
5739 PyThreadState* __tstate = wxPyBeginAllowThreads();
5740 (arg1)->SetBottom(arg2);
5741
5742 wxPyEndAllowThreads(__tstate);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 Py_INCREF(Py_None); resultobj = Py_None;
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj;
5754 wxRect *arg1 = (wxRect *) 0 ;
5755 int arg2 ;
5756 int arg3 ;
5757 wxRect *result;
5758 PyObject * obj0 = 0 ;
5759 PyObject * obj1 = 0 ;
5760 PyObject * obj2 = 0 ;
5761 char *kwnames[] = {
5762 (char *) "self",(char *) "dx",(char *) "dy", NULL
5763 };
5764
5765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5767 if (SWIG_arg_fail(1)) SWIG_fail;
5768 {
5769 arg2 = (int)(SWIG_As_int(obj1));
5770 if (SWIG_arg_fail(2)) SWIG_fail;
5771 }
5772 {
5773 arg3 = (int)(SWIG_As_int(obj2));
5774 if (SWIG_arg_fail(3)) SWIG_fail;
5775 }
5776 {
5777 PyThreadState* __tstate = wxPyBeginAllowThreads();
5778 {
5779 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5780 result = (wxRect *) &_result_ref;
5781 }
5782
5783 wxPyEndAllowThreads(__tstate);
5784 if (PyErr_Occurred()) SWIG_fail;
5785 }
5786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5787 return resultobj;
5788 fail:
5789 return NULL;
5790 }
5791
5792
5793 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5794 PyObject *resultobj;
5795 wxRect *arg1 = (wxRect *) 0 ;
5796 int arg2 ;
5797 int arg3 ;
5798 wxRect *result;
5799 PyObject * obj0 = 0 ;
5800 PyObject * obj1 = 0 ;
5801 PyObject * obj2 = 0 ;
5802 char *kwnames[] = {
5803 (char *) "self",(char *) "dx",(char *) "dy", NULL
5804 };
5805
5806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5808 if (SWIG_arg_fail(1)) SWIG_fail;
5809 {
5810 arg2 = (int)(SWIG_As_int(obj1));
5811 if (SWIG_arg_fail(2)) SWIG_fail;
5812 }
5813 {
5814 arg3 = (int)(SWIG_As_int(obj2));
5815 if (SWIG_arg_fail(3)) SWIG_fail;
5816 }
5817 {
5818 PyThreadState* __tstate = wxPyBeginAllowThreads();
5819 {
5820 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5821 result = (wxRect *) &_result_ref;
5822 }
5823
5824 wxPyEndAllowThreads(__tstate);
5825 if (PyErr_Occurred()) SWIG_fail;
5826 }
5827 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5828 return resultobj;
5829 fail:
5830 return NULL;
5831 }
5832
5833
5834 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5835 PyObject *resultobj;
5836 wxRect *arg1 = (wxRect *) 0 ;
5837 int arg2 ;
5838 int arg3 ;
5839 PyObject * obj0 = 0 ;
5840 PyObject * obj1 = 0 ;
5841 PyObject * obj2 = 0 ;
5842 char *kwnames[] = {
5843 (char *) "self",(char *) "dx",(char *) "dy", NULL
5844 };
5845
5846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5848 if (SWIG_arg_fail(1)) SWIG_fail;
5849 {
5850 arg2 = (int)(SWIG_As_int(obj1));
5851 if (SWIG_arg_fail(2)) SWIG_fail;
5852 }
5853 {
5854 arg3 = (int)(SWIG_As_int(obj2));
5855 if (SWIG_arg_fail(3)) SWIG_fail;
5856 }
5857 {
5858 PyThreadState* __tstate = wxPyBeginAllowThreads();
5859 (arg1)->Offset(arg2,arg3);
5860
5861 wxPyEndAllowThreads(__tstate);
5862 if (PyErr_Occurred()) SWIG_fail;
5863 }
5864 Py_INCREF(Py_None); resultobj = Py_None;
5865 return resultobj;
5866 fail:
5867 return NULL;
5868 }
5869
5870
5871 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5872 PyObject *resultobj;
5873 wxRect *arg1 = (wxRect *) 0 ;
5874 wxPoint *arg2 = 0 ;
5875 wxPoint temp2 ;
5876 PyObject * obj0 = 0 ;
5877 PyObject * obj1 = 0 ;
5878 char *kwnames[] = {
5879 (char *) "self",(char *) "pt", NULL
5880 };
5881
5882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5884 if (SWIG_arg_fail(1)) SWIG_fail;
5885 {
5886 arg2 = &temp2;
5887 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5888 }
5889 {
5890 PyThreadState* __tstate = wxPyBeginAllowThreads();
5891 (arg1)->Offset((wxPoint const &)*arg2);
5892
5893 wxPyEndAllowThreads(__tstate);
5894 if (PyErr_Occurred()) SWIG_fail;
5895 }
5896 Py_INCREF(Py_None); resultobj = Py_None;
5897 return resultobj;
5898 fail:
5899 return NULL;
5900 }
5901
5902
5903 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5904 PyObject *resultobj;
5905 wxRect *arg1 = (wxRect *) 0 ;
5906 wxRect *arg2 = 0 ;
5907 wxRect result;
5908 wxRect temp2 ;
5909 PyObject * obj0 = 0 ;
5910 PyObject * obj1 = 0 ;
5911 char *kwnames[] = {
5912 (char *) "self",(char *) "rect", NULL
5913 };
5914
5915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5917 if (SWIG_arg_fail(1)) SWIG_fail;
5918 {
5919 arg2 = &temp2;
5920 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5921 }
5922 {
5923 PyThreadState* __tstate = wxPyBeginAllowThreads();
5924 result = (arg1)->Intersect((wxRect const &)*arg2);
5925
5926 wxPyEndAllowThreads(__tstate);
5927 if (PyErr_Occurred()) SWIG_fail;
5928 }
5929 {
5930 wxRect * resultptr;
5931 resultptr = new wxRect((wxRect &)(result));
5932 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5933 }
5934 return resultobj;
5935 fail:
5936 return NULL;
5937 }
5938
5939
5940 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5941 PyObject *resultobj;
5942 wxRect *arg1 = (wxRect *) 0 ;
5943 wxRect *arg2 = 0 ;
5944 wxRect result;
5945 wxRect temp2 ;
5946 PyObject * obj0 = 0 ;
5947 PyObject * obj1 = 0 ;
5948 char *kwnames[] = {
5949 (char *) "self",(char *) "rect", NULL
5950 };
5951
5952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5954 if (SWIG_arg_fail(1)) SWIG_fail;
5955 {
5956 arg2 = &temp2;
5957 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5958 }
5959 {
5960 PyThreadState* __tstate = wxPyBeginAllowThreads();
5961 result = (arg1)->Union((wxRect const &)*arg2);
5962
5963 wxPyEndAllowThreads(__tstate);
5964 if (PyErr_Occurred()) SWIG_fail;
5965 }
5966 {
5967 wxRect * resultptr;
5968 resultptr = new wxRect((wxRect &)(result));
5969 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5970 }
5971 return resultobj;
5972 fail:
5973 return NULL;
5974 }
5975
5976
5977 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5978 PyObject *resultobj;
5979 wxRect *arg1 = (wxRect *) 0 ;
5980 wxRect *arg2 = 0 ;
5981 wxRect result;
5982 wxRect temp2 ;
5983 PyObject * obj0 = 0 ;
5984 PyObject * obj1 = 0 ;
5985 char *kwnames[] = {
5986 (char *) "self",(char *) "rect", NULL
5987 };
5988
5989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5991 if (SWIG_arg_fail(1)) SWIG_fail;
5992 {
5993 arg2 = &temp2;
5994 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5995 }
5996 {
5997 PyThreadState* __tstate = wxPyBeginAllowThreads();
5998 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5999
6000 wxPyEndAllowThreads(__tstate);
6001 if (PyErr_Occurred()) SWIG_fail;
6002 }
6003 {
6004 wxRect * resultptr;
6005 resultptr = new wxRect((wxRect &)(result));
6006 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6007 }
6008 return resultobj;
6009 fail:
6010 return NULL;
6011 }
6012
6013
6014 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6015 PyObject *resultobj;
6016 wxRect *arg1 = (wxRect *) 0 ;
6017 wxRect *arg2 = 0 ;
6018 wxRect *result;
6019 wxRect temp2 ;
6020 PyObject * obj0 = 0 ;
6021 PyObject * obj1 = 0 ;
6022 char *kwnames[] = {
6023 (char *) "self",(char *) "rect", NULL
6024 };
6025
6026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6028 if (SWIG_arg_fail(1)) SWIG_fail;
6029 {
6030 arg2 = &temp2;
6031 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6032 }
6033 {
6034 PyThreadState* __tstate = wxPyBeginAllowThreads();
6035 {
6036 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6037 result = (wxRect *) &_result_ref;
6038 }
6039
6040 wxPyEndAllowThreads(__tstate);
6041 if (PyErr_Occurred()) SWIG_fail;
6042 }
6043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6044 return resultobj;
6045 fail:
6046 return NULL;
6047 }
6048
6049
6050 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6051 PyObject *resultobj;
6052 wxRect *arg1 = (wxRect *) 0 ;
6053 wxRect *arg2 = 0 ;
6054 bool result;
6055 wxRect temp2 ;
6056 PyObject * obj0 = 0 ;
6057 PyObject * obj1 = 0 ;
6058 char *kwnames[] = {
6059 (char *) "self",(char *) "rect", NULL
6060 };
6061
6062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6064 if (SWIG_arg_fail(1)) SWIG_fail;
6065 {
6066 arg2 = &temp2;
6067 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6068 }
6069 {
6070 PyThreadState* __tstate = wxPyBeginAllowThreads();
6071 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6072
6073 wxPyEndAllowThreads(__tstate);
6074 if (PyErr_Occurred()) SWIG_fail;
6075 }
6076 {
6077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6078 }
6079 return resultobj;
6080 fail:
6081 return NULL;
6082 }
6083
6084
6085 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6086 PyObject *resultobj;
6087 wxRect *arg1 = (wxRect *) 0 ;
6088 wxRect *arg2 = 0 ;
6089 bool result;
6090 wxRect temp2 ;
6091 PyObject * obj0 = 0 ;
6092 PyObject * obj1 = 0 ;
6093 char *kwnames[] = {
6094 (char *) "self",(char *) "rect", NULL
6095 };
6096
6097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6099 if (SWIG_arg_fail(1)) SWIG_fail;
6100 {
6101 arg2 = &temp2;
6102 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6103 }
6104 {
6105 PyThreadState* __tstate = wxPyBeginAllowThreads();
6106 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6107
6108 wxPyEndAllowThreads(__tstate);
6109 if (PyErr_Occurred()) SWIG_fail;
6110 }
6111 {
6112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6113 }
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj;
6122 wxRect *arg1 = (wxRect *) 0 ;
6123 int arg2 ;
6124 int arg3 ;
6125 bool result;
6126 PyObject * obj0 = 0 ;
6127 PyObject * obj1 = 0 ;
6128 PyObject * obj2 = 0 ;
6129 char *kwnames[] = {
6130 (char *) "self",(char *) "x",(char *) "y", NULL
6131 };
6132
6133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6135 if (SWIG_arg_fail(1)) SWIG_fail;
6136 {
6137 arg2 = (int)(SWIG_As_int(obj1));
6138 if (SWIG_arg_fail(2)) SWIG_fail;
6139 }
6140 {
6141 arg3 = (int)(SWIG_As_int(obj2));
6142 if (SWIG_arg_fail(3)) SWIG_fail;
6143 }
6144 {
6145 PyThreadState* __tstate = wxPyBeginAllowThreads();
6146 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6147
6148 wxPyEndAllowThreads(__tstate);
6149 if (PyErr_Occurred()) SWIG_fail;
6150 }
6151 {
6152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6153 }
6154 return resultobj;
6155 fail:
6156 return NULL;
6157 }
6158
6159
6160 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6161 PyObject *resultobj;
6162 wxRect *arg1 = (wxRect *) 0 ;
6163 wxPoint *arg2 = 0 ;
6164 bool result;
6165 wxPoint temp2 ;
6166 PyObject * obj0 = 0 ;
6167 PyObject * obj1 = 0 ;
6168 char *kwnames[] = {
6169 (char *) "self",(char *) "pt", NULL
6170 };
6171
6172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6174 if (SWIG_arg_fail(1)) SWIG_fail;
6175 {
6176 arg2 = &temp2;
6177 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6178 }
6179 {
6180 PyThreadState* __tstate = wxPyBeginAllowThreads();
6181 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6182
6183 wxPyEndAllowThreads(__tstate);
6184 if (PyErr_Occurred()) SWIG_fail;
6185 }
6186 {
6187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6188 }
6189 return resultobj;
6190 fail:
6191 return NULL;
6192 }
6193
6194
6195 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6196 PyObject *resultobj;
6197 wxRect *arg1 = (wxRect *) 0 ;
6198 wxRect *arg2 = 0 ;
6199 bool result;
6200 wxRect temp2 ;
6201 PyObject * obj0 = 0 ;
6202 PyObject * obj1 = 0 ;
6203 char *kwnames[] = {
6204 (char *) "self",(char *) "rect", NULL
6205 };
6206
6207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6209 if (SWIG_arg_fail(1)) SWIG_fail;
6210 {
6211 arg2 = &temp2;
6212 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6213 }
6214 {
6215 PyThreadState* __tstate = wxPyBeginAllowThreads();
6216 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6217
6218 wxPyEndAllowThreads(__tstate);
6219 if (PyErr_Occurred()) SWIG_fail;
6220 }
6221 {
6222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6223 }
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6231 PyObject *resultobj;
6232 wxRect *arg1 = (wxRect *) 0 ;
6233 int arg2 ;
6234 PyObject * obj0 = 0 ;
6235 PyObject * obj1 = 0 ;
6236 char *kwnames[] = {
6237 (char *) "self",(char *) "x", NULL
6238 };
6239
6240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6242 if (SWIG_arg_fail(1)) SWIG_fail;
6243 {
6244 arg2 = (int)(SWIG_As_int(obj1));
6245 if (SWIG_arg_fail(2)) SWIG_fail;
6246 }
6247 if (arg1) (arg1)->x = arg2;
6248
6249 Py_INCREF(Py_None); resultobj = Py_None;
6250 return resultobj;
6251 fail:
6252 return NULL;
6253 }
6254
6255
6256 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6257 PyObject *resultobj;
6258 wxRect *arg1 = (wxRect *) 0 ;
6259 int result;
6260 PyObject * obj0 = 0 ;
6261 char *kwnames[] = {
6262 (char *) "self", NULL
6263 };
6264
6265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6267 if (SWIG_arg_fail(1)) SWIG_fail;
6268 result = (int) ((arg1)->x);
6269
6270 {
6271 resultobj = SWIG_From_int((int)(result));
6272 }
6273 return resultobj;
6274 fail:
6275 return NULL;
6276 }
6277
6278
6279 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6280 PyObject *resultobj;
6281 wxRect *arg1 = (wxRect *) 0 ;
6282 int arg2 ;
6283 PyObject * obj0 = 0 ;
6284 PyObject * obj1 = 0 ;
6285 char *kwnames[] = {
6286 (char *) "self",(char *) "y", NULL
6287 };
6288
6289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6291 if (SWIG_arg_fail(1)) SWIG_fail;
6292 {
6293 arg2 = (int)(SWIG_As_int(obj1));
6294 if (SWIG_arg_fail(2)) SWIG_fail;
6295 }
6296 if (arg1) (arg1)->y = arg2;
6297
6298 Py_INCREF(Py_None); resultobj = Py_None;
6299 return resultobj;
6300 fail:
6301 return NULL;
6302 }
6303
6304
6305 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6306 PyObject *resultobj;
6307 wxRect *arg1 = (wxRect *) 0 ;
6308 int result;
6309 PyObject * obj0 = 0 ;
6310 char *kwnames[] = {
6311 (char *) "self", NULL
6312 };
6313
6314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6316 if (SWIG_arg_fail(1)) SWIG_fail;
6317 result = (int) ((arg1)->y);
6318
6319 {
6320 resultobj = SWIG_From_int((int)(result));
6321 }
6322 return resultobj;
6323 fail:
6324 return NULL;
6325 }
6326
6327
6328 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6329 PyObject *resultobj;
6330 wxRect *arg1 = (wxRect *) 0 ;
6331 int arg2 ;
6332 PyObject * obj0 = 0 ;
6333 PyObject * obj1 = 0 ;
6334 char *kwnames[] = {
6335 (char *) "self",(char *) "width", NULL
6336 };
6337
6338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6340 if (SWIG_arg_fail(1)) SWIG_fail;
6341 {
6342 arg2 = (int)(SWIG_As_int(obj1));
6343 if (SWIG_arg_fail(2)) SWIG_fail;
6344 }
6345 if (arg1) (arg1)->width = arg2;
6346
6347 Py_INCREF(Py_None); resultobj = Py_None;
6348 return resultobj;
6349 fail:
6350 return NULL;
6351 }
6352
6353
6354 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6355 PyObject *resultobj;
6356 wxRect *arg1 = (wxRect *) 0 ;
6357 int result;
6358 PyObject * obj0 = 0 ;
6359 char *kwnames[] = {
6360 (char *) "self", NULL
6361 };
6362
6363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6365 if (SWIG_arg_fail(1)) SWIG_fail;
6366 result = (int) ((arg1)->width);
6367
6368 {
6369 resultobj = SWIG_From_int((int)(result));
6370 }
6371 return resultobj;
6372 fail:
6373 return NULL;
6374 }
6375
6376
6377 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6378 PyObject *resultobj;
6379 wxRect *arg1 = (wxRect *) 0 ;
6380 int arg2 ;
6381 PyObject * obj0 = 0 ;
6382 PyObject * obj1 = 0 ;
6383 char *kwnames[] = {
6384 (char *) "self",(char *) "height", NULL
6385 };
6386
6387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6389 if (SWIG_arg_fail(1)) SWIG_fail;
6390 {
6391 arg2 = (int)(SWIG_As_int(obj1));
6392 if (SWIG_arg_fail(2)) SWIG_fail;
6393 }
6394 if (arg1) (arg1)->height = arg2;
6395
6396 Py_INCREF(Py_None); resultobj = Py_None;
6397 return resultobj;
6398 fail:
6399 return NULL;
6400 }
6401
6402
6403 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6404 PyObject *resultobj;
6405 wxRect *arg1 = (wxRect *) 0 ;
6406 int result;
6407 PyObject * obj0 = 0 ;
6408 char *kwnames[] = {
6409 (char *) "self", NULL
6410 };
6411
6412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6414 if (SWIG_arg_fail(1)) SWIG_fail;
6415 result = (int) ((arg1)->height);
6416
6417 {
6418 resultobj = SWIG_From_int((int)(result));
6419 }
6420 return resultobj;
6421 fail:
6422 return NULL;
6423 }
6424
6425
6426 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6427 PyObject *resultobj;
6428 wxRect *arg1 = (wxRect *) 0 ;
6429 int arg2 = (int) 0 ;
6430 int arg3 = (int) 0 ;
6431 int arg4 = (int) 0 ;
6432 int arg5 = (int) 0 ;
6433 PyObject * obj0 = 0 ;
6434 PyObject * obj1 = 0 ;
6435 PyObject * obj2 = 0 ;
6436 PyObject * obj3 = 0 ;
6437 PyObject * obj4 = 0 ;
6438 char *kwnames[] = {
6439 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6440 };
6441
6442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6444 if (SWIG_arg_fail(1)) SWIG_fail;
6445 if (obj1) {
6446 {
6447 arg2 = (int)(SWIG_As_int(obj1));
6448 if (SWIG_arg_fail(2)) SWIG_fail;
6449 }
6450 }
6451 if (obj2) {
6452 {
6453 arg3 = (int)(SWIG_As_int(obj2));
6454 if (SWIG_arg_fail(3)) SWIG_fail;
6455 }
6456 }
6457 if (obj3) {
6458 {
6459 arg4 = (int)(SWIG_As_int(obj3));
6460 if (SWIG_arg_fail(4)) SWIG_fail;
6461 }
6462 }
6463 if (obj4) {
6464 {
6465 arg5 = (int)(SWIG_As_int(obj4));
6466 if (SWIG_arg_fail(5)) SWIG_fail;
6467 }
6468 }
6469 {
6470 PyThreadState* __tstate = wxPyBeginAllowThreads();
6471 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6472
6473 wxPyEndAllowThreads(__tstate);
6474 if (PyErr_Occurred()) SWIG_fail;
6475 }
6476 Py_INCREF(Py_None); resultobj = Py_None;
6477 return resultobj;
6478 fail:
6479 return NULL;
6480 }
6481
6482
6483 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6484 PyObject *resultobj;
6485 wxRect *arg1 = (wxRect *) 0 ;
6486 PyObject *result;
6487 PyObject * obj0 = 0 ;
6488 char *kwnames[] = {
6489 (char *) "self", NULL
6490 };
6491
6492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6494 if (SWIG_arg_fail(1)) SWIG_fail;
6495 {
6496 PyThreadState* __tstate = wxPyBeginAllowThreads();
6497 result = (PyObject *)wxRect_Get(arg1);
6498
6499 wxPyEndAllowThreads(__tstate);
6500 if (PyErr_Occurred()) SWIG_fail;
6501 }
6502 resultobj = result;
6503 return resultobj;
6504 fail:
6505 return NULL;
6506 }
6507
6508
6509 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6510 PyObject *obj;
6511 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6512 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6513 Py_INCREF(obj);
6514 return Py_BuildValue((char *)"");
6515 }
6516 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6517 PyObject *resultobj;
6518 wxRect *arg1 = (wxRect *) 0 ;
6519 wxRect *arg2 = (wxRect *) 0 ;
6520 PyObject *result;
6521 PyObject * obj0 = 0 ;
6522 PyObject * obj1 = 0 ;
6523 char *kwnames[] = {
6524 (char *) "r1",(char *) "r2", NULL
6525 };
6526
6527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6529 if (SWIG_arg_fail(1)) SWIG_fail;
6530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6531 if (SWIG_arg_fail(2)) SWIG_fail;
6532 {
6533 if (!wxPyCheckForApp()) SWIG_fail;
6534 PyThreadState* __tstate = wxPyBeginAllowThreads();
6535 result = (PyObject *)wxIntersectRect(arg1,arg2);
6536
6537 wxPyEndAllowThreads(__tstate);
6538 if (PyErr_Occurred()) SWIG_fail;
6539 }
6540 resultobj = result;
6541 return resultobj;
6542 fail:
6543 return NULL;
6544 }
6545
6546
6547 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6548 PyObject *resultobj;
6549 double arg1 = (double) 0.0 ;
6550 double arg2 = (double) 0.0 ;
6551 wxPoint2D *result;
6552 PyObject * obj0 = 0 ;
6553 PyObject * obj1 = 0 ;
6554 char *kwnames[] = {
6555 (char *) "x",(char *) "y", NULL
6556 };
6557
6558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6559 if (obj0) {
6560 {
6561 arg1 = (double)(SWIG_As_double(obj0));
6562 if (SWIG_arg_fail(1)) SWIG_fail;
6563 }
6564 }
6565 if (obj1) {
6566 {
6567 arg2 = (double)(SWIG_As_double(obj1));
6568 if (SWIG_arg_fail(2)) SWIG_fail;
6569 }
6570 }
6571 {
6572 PyThreadState* __tstate = wxPyBeginAllowThreads();
6573 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6574
6575 wxPyEndAllowThreads(__tstate);
6576 if (PyErr_Occurred()) SWIG_fail;
6577 }
6578 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6579 return resultobj;
6580 fail:
6581 return NULL;
6582 }
6583
6584
6585 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6586 PyObject *resultobj;
6587 wxPoint2D *arg1 = 0 ;
6588 wxPoint2D *result;
6589 wxPoint2D temp1 ;
6590 PyObject * obj0 = 0 ;
6591 char *kwnames[] = {
6592 (char *) "pt", NULL
6593 };
6594
6595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6596 {
6597 arg1 = &temp1;
6598 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6599 }
6600 {
6601 PyThreadState* __tstate = wxPyBeginAllowThreads();
6602 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6603
6604 wxPyEndAllowThreads(__tstate);
6605 if (PyErr_Occurred()) SWIG_fail;
6606 }
6607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6608 return resultobj;
6609 fail:
6610 return NULL;
6611 }
6612
6613
6614 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6615 PyObject *resultobj;
6616 wxPoint *arg1 = 0 ;
6617 wxPoint2D *result;
6618 wxPoint temp1 ;
6619 PyObject * obj0 = 0 ;
6620 char *kwnames[] = {
6621 (char *) "pt", NULL
6622 };
6623
6624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6625 {
6626 arg1 = &temp1;
6627 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6628 }
6629 {
6630 PyThreadState* __tstate = wxPyBeginAllowThreads();
6631 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6632
6633 wxPyEndAllowThreads(__tstate);
6634 if (PyErr_Occurred()) SWIG_fail;
6635 }
6636 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6637 return resultobj;
6638 fail:
6639 return NULL;
6640 }
6641
6642
6643 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6644 PyObject *resultobj;
6645 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6646 int *arg2 = (int *) 0 ;
6647 int *arg3 = (int *) 0 ;
6648 int temp2 ;
6649 int res2 = 0 ;
6650 int temp3 ;
6651 int res3 = 0 ;
6652 PyObject * obj0 = 0 ;
6653 char *kwnames[] = {
6654 (char *) "self", NULL
6655 };
6656
6657 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6658 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6661 if (SWIG_arg_fail(1)) SWIG_fail;
6662 {
6663 PyThreadState* __tstate = wxPyBeginAllowThreads();
6664 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6665
6666 wxPyEndAllowThreads(__tstate);
6667 if (PyErr_Occurred()) SWIG_fail;
6668 }
6669 Py_INCREF(Py_None); resultobj = Py_None;
6670 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6671 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6672 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6673 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6674 return resultobj;
6675 fail:
6676 return NULL;
6677 }
6678
6679
6680 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6681 PyObject *resultobj;
6682 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6683 int *arg2 = (int *) 0 ;
6684 int *arg3 = (int *) 0 ;
6685 int temp2 ;
6686 int res2 = 0 ;
6687 int temp3 ;
6688 int res3 = 0 ;
6689 PyObject * obj0 = 0 ;
6690 char *kwnames[] = {
6691 (char *) "self", NULL
6692 };
6693
6694 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6695 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6698 if (SWIG_arg_fail(1)) SWIG_fail;
6699 {
6700 PyThreadState* __tstate = wxPyBeginAllowThreads();
6701 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6702
6703 wxPyEndAllowThreads(__tstate);
6704 if (PyErr_Occurred()) SWIG_fail;
6705 }
6706 Py_INCREF(Py_None); resultobj = Py_None;
6707 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6708 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6709 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6710 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6711 return resultobj;
6712 fail:
6713 return NULL;
6714 }
6715
6716
6717 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6718 PyObject *resultobj;
6719 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6720 double result;
6721 PyObject * obj0 = 0 ;
6722 char *kwnames[] = {
6723 (char *) "self", NULL
6724 };
6725
6726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6728 if (SWIG_arg_fail(1)) SWIG_fail;
6729 {
6730 PyThreadState* __tstate = wxPyBeginAllowThreads();
6731 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6732
6733 wxPyEndAllowThreads(__tstate);
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 {
6737 resultobj = SWIG_From_double((double)(result));
6738 }
6739 return resultobj;
6740 fail:
6741 return NULL;
6742 }
6743
6744
6745 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6746 PyObject *resultobj;
6747 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6748 double result;
6749 PyObject * obj0 = 0 ;
6750 char *kwnames[] = {
6751 (char *) "self", NULL
6752 };
6753
6754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6756 if (SWIG_arg_fail(1)) SWIG_fail;
6757 {
6758 PyThreadState* __tstate = wxPyBeginAllowThreads();
6759 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6760
6761 wxPyEndAllowThreads(__tstate);
6762 if (PyErr_Occurred()) SWIG_fail;
6763 }
6764 {
6765 resultobj = SWIG_From_double((double)(result));
6766 }
6767 return resultobj;
6768 fail:
6769 return NULL;
6770 }
6771
6772
6773 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6774 PyObject *resultobj;
6775 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6776 double arg2 ;
6777 PyObject * obj0 = 0 ;
6778 PyObject * obj1 = 0 ;
6779 char *kwnames[] = {
6780 (char *) "self",(char *) "length", NULL
6781 };
6782
6783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6785 if (SWIG_arg_fail(1)) SWIG_fail;
6786 {
6787 arg2 = (double)(SWIG_As_double(obj1));
6788 if (SWIG_arg_fail(2)) SWIG_fail;
6789 }
6790 {
6791 PyThreadState* __tstate = wxPyBeginAllowThreads();
6792 (arg1)->SetVectorLength(arg2);
6793
6794 wxPyEndAllowThreads(__tstate);
6795 if (PyErr_Occurred()) SWIG_fail;
6796 }
6797 Py_INCREF(Py_None); resultobj = Py_None;
6798 return resultobj;
6799 fail:
6800 return NULL;
6801 }
6802
6803
6804 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6805 PyObject *resultobj;
6806 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6807 double arg2 ;
6808 PyObject * obj0 = 0 ;
6809 PyObject * obj1 = 0 ;
6810 char *kwnames[] = {
6811 (char *) "self",(char *) "degrees", NULL
6812 };
6813
6814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6816 if (SWIG_arg_fail(1)) SWIG_fail;
6817 {
6818 arg2 = (double)(SWIG_As_double(obj1));
6819 if (SWIG_arg_fail(2)) SWIG_fail;
6820 }
6821 {
6822 PyThreadState* __tstate = wxPyBeginAllowThreads();
6823 (arg1)->SetVectorAngle(arg2);
6824
6825 wxPyEndAllowThreads(__tstate);
6826 if (PyErr_Occurred()) SWIG_fail;
6827 }
6828 Py_INCREF(Py_None); resultobj = Py_None;
6829 return resultobj;
6830 fail:
6831 return NULL;
6832 }
6833
6834
6835 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6836 PyObject *resultobj;
6837 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6838 wxPoint2D *arg2 = 0 ;
6839 double result;
6840 wxPoint2D temp2 ;
6841 PyObject * obj0 = 0 ;
6842 PyObject * obj1 = 0 ;
6843 char *kwnames[] = {
6844 (char *) "self",(char *) "pt", NULL
6845 };
6846
6847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6849 if (SWIG_arg_fail(1)) SWIG_fail;
6850 {
6851 arg2 = &temp2;
6852 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6853 }
6854 {
6855 PyThreadState* __tstate = wxPyBeginAllowThreads();
6856 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6857
6858 wxPyEndAllowThreads(__tstate);
6859 if (PyErr_Occurred()) SWIG_fail;
6860 }
6861 {
6862 resultobj = SWIG_From_double((double)(result));
6863 }
6864 return resultobj;
6865 fail:
6866 return NULL;
6867 }
6868
6869
6870 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6871 PyObject *resultobj;
6872 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6873 wxPoint2D *arg2 = 0 ;
6874 double result;
6875 wxPoint2D temp2 ;
6876 PyObject * obj0 = 0 ;
6877 PyObject * obj1 = 0 ;
6878 char *kwnames[] = {
6879 (char *) "self",(char *) "pt", NULL
6880 };
6881
6882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6884 if (SWIG_arg_fail(1)) SWIG_fail;
6885 {
6886 arg2 = &temp2;
6887 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6888 }
6889 {
6890 PyThreadState* __tstate = wxPyBeginAllowThreads();
6891 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6892
6893 wxPyEndAllowThreads(__tstate);
6894 if (PyErr_Occurred()) SWIG_fail;
6895 }
6896 {
6897 resultobj = SWIG_From_double((double)(result));
6898 }
6899 return resultobj;
6900 fail:
6901 return NULL;
6902 }
6903
6904
6905 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6906 PyObject *resultobj;
6907 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6908 wxPoint2D *arg2 = 0 ;
6909 double result;
6910 wxPoint2D temp2 ;
6911 PyObject * obj0 = 0 ;
6912 PyObject * obj1 = 0 ;
6913 char *kwnames[] = {
6914 (char *) "self",(char *) "vec", NULL
6915 };
6916
6917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6919 if (SWIG_arg_fail(1)) SWIG_fail;
6920 {
6921 arg2 = &temp2;
6922 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6923 }
6924 {
6925 PyThreadState* __tstate = wxPyBeginAllowThreads();
6926 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6927
6928 wxPyEndAllowThreads(__tstate);
6929 if (PyErr_Occurred()) SWIG_fail;
6930 }
6931 {
6932 resultobj = SWIG_From_double((double)(result));
6933 }
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6941 PyObject *resultobj;
6942 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6943 wxPoint2D *arg2 = 0 ;
6944 double result;
6945 wxPoint2D temp2 ;
6946 PyObject * obj0 = 0 ;
6947 PyObject * obj1 = 0 ;
6948 char *kwnames[] = {
6949 (char *) "self",(char *) "vec", NULL
6950 };
6951
6952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6954 if (SWIG_arg_fail(1)) SWIG_fail;
6955 {
6956 arg2 = &temp2;
6957 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6958 }
6959 {
6960 PyThreadState* __tstate = wxPyBeginAllowThreads();
6961 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6962
6963 wxPyEndAllowThreads(__tstate);
6964 if (PyErr_Occurred()) SWIG_fail;
6965 }
6966 {
6967 resultobj = SWIG_From_double((double)(result));
6968 }
6969 return resultobj;
6970 fail:
6971 return NULL;
6972 }
6973
6974
6975 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6976 PyObject *resultobj;
6977 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6978 wxPoint2D result;
6979 PyObject * obj0 = 0 ;
6980 char *kwnames[] = {
6981 (char *) "self", NULL
6982 };
6983
6984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6986 if (SWIG_arg_fail(1)) SWIG_fail;
6987 {
6988 PyThreadState* __tstate = wxPyBeginAllowThreads();
6989 result = (arg1)->operator -();
6990
6991 wxPyEndAllowThreads(__tstate);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 {
6995 wxPoint2D * resultptr;
6996 resultptr = new wxPoint2D((wxPoint2D &)(result));
6997 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6998 }
6999 return resultobj;
7000 fail:
7001 return NULL;
7002 }
7003
7004
7005 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
7006 PyObject *resultobj;
7007 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7008 wxPoint2D *arg2 = 0 ;
7009 wxPoint2D *result;
7010 wxPoint2D temp2 ;
7011 PyObject * obj0 = 0 ;
7012 PyObject * obj1 = 0 ;
7013 char *kwnames[] = {
7014 (char *) "self",(char *) "pt", NULL
7015 };
7016
7017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
7018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7019 if (SWIG_arg_fail(1)) SWIG_fail;
7020 {
7021 arg2 = &temp2;
7022 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7023 }
7024 {
7025 PyThreadState* __tstate = wxPyBeginAllowThreads();
7026 {
7027 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7028 result = (wxPoint2D *) &_result_ref;
7029 }
7030
7031 wxPyEndAllowThreads(__tstate);
7032 if (PyErr_Occurred()) SWIG_fail;
7033 }
7034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7035 return resultobj;
7036 fail:
7037 return NULL;
7038 }
7039
7040
7041 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7042 PyObject *resultobj;
7043 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7044 wxPoint2D *arg2 = 0 ;
7045 wxPoint2D *result;
7046 wxPoint2D temp2 ;
7047 PyObject * obj0 = 0 ;
7048 PyObject * obj1 = 0 ;
7049 char *kwnames[] = {
7050 (char *) "self",(char *) "pt", NULL
7051 };
7052
7053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7055 if (SWIG_arg_fail(1)) SWIG_fail;
7056 {
7057 arg2 = &temp2;
7058 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7059 }
7060 {
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 {
7063 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7064 result = (wxPoint2D *) &_result_ref;
7065 }
7066
7067 wxPyEndAllowThreads(__tstate);
7068 if (PyErr_Occurred()) SWIG_fail;
7069 }
7070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7071 return resultobj;
7072 fail:
7073 return NULL;
7074 }
7075
7076
7077 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7078 PyObject *resultobj;
7079 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7080 wxPoint2D *arg2 = 0 ;
7081 wxPoint2D *result;
7082 wxPoint2D temp2 ;
7083 PyObject * obj0 = 0 ;
7084 PyObject * obj1 = 0 ;
7085 char *kwnames[] = {
7086 (char *) "self",(char *) "pt", NULL
7087 };
7088
7089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7091 if (SWIG_arg_fail(1)) SWIG_fail;
7092 {
7093 arg2 = &temp2;
7094 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7095 }
7096 {
7097 PyThreadState* __tstate = wxPyBeginAllowThreads();
7098 {
7099 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7100 result = (wxPoint2D *) &_result_ref;
7101 }
7102
7103 wxPyEndAllowThreads(__tstate);
7104 if (PyErr_Occurred()) SWIG_fail;
7105 }
7106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7107 return resultobj;
7108 fail:
7109 return NULL;
7110 }
7111
7112
7113 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7114 PyObject *resultobj;
7115 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7116 wxPoint2D *arg2 = 0 ;
7117 wxPoint2D *result;
7118 wxPoint2D temp2 ;
7119 PyObject * obj0 = 0 ;
7120 PyObject * obj1 = 0 ;
7121 char *kwnames[] = {
7122 (char *) "self",(char *) "pt", NULL
7123 };
7124
7125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7127 if (SWIG_arg_fail(1)) SWIG_fail;
7128 {
7129 arg2 = &temp2;
7130 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7131 }
7132 {
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 {
7135 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7136 result = (wxPoint2D *) &_result_ref;
7137 }
7138
7139 wxPyEndAllowThreads(__tstate);
7140 if (PyErr_Occurred()) SWIG_fail;
7141 }
7142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7143 return resultobj;
7144 fail:
7145 return NULL;
7146 }
7147
7148
7149 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7150 PyObject *resultobj;
7151 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7152 wxPoint2D *arg2 = 0 ;
7153 bool result;
7154 wxPoint2D temp2 ;
7155 PyObject * obj0 = 0 ;
7156 PyObject * obj1 = 0 ;
7157 char *kwnames[] = {
7158 (char *) "self",(char *) "pt", NULL
7159 };
7160
7161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7163 if (SWIG_arg_fail(1)) SWIG_fail;
7164 {
7165 arg2 = &temp2;
7166 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7167 }
7168 {
7169 PyThreadState* __tstate = wxPyBeginAllowThreads();
7170 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7171
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 {
7176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7177 }
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj;
7186 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7187 wxPoint2D *arg2 = 0 ;
7188 bool result;
7189 wxPoint2D temp2 ;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 char *kwnames[] = {
7193 (char *) "self",(char *) "pt", NULL
7194 };
7195
7196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7198 if (SWIG_arg_fail(1)) SWIG_fail;
7199 {
7200 arg2 = &temp2;
7201 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7202 }
7203 {
7204 PyThreadState* __tstate = wxPyBeginAllowThreads();
7205 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7206
7207 wxPyEndAllowThreads(__tstate);
7208 if (PyErr_Occurred()) SWIG_fail;
7209 }
7210 {
7211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7212 }
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj;
7221 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7222 double arg2 ;
7223 PyObject * obj0 = 0 ;
7224 PyObject * obj1 = 0 ;
7225 char *kwnames[] = {
7226 (char *) "self",(char *) "m_x", NULL
7227 };
7228
7229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7231 if (SWIG_arg_fail(1)) SWIG_fail;
7232 {
7233 arg2 = (double)(SWIG_As_double(obj1));
7234 if (SWIG_arg_fail(2)) SWIG_fail;
7235 }
7236 if (arg1) (arg1)->m_x = arg2;
7237
7238 Py_INCREF(Py_None); resultobj = Py_None;
7239 return resultobj;
7240 fail:
7241 return NULL;
7242 }
7243
7244
7245 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7246 PyObject *resultobj;
7247 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7248 double result;
7249 PyObject * obj0 = 0 ;
7250 char *kwnames[] = {
7251 (char *) "self", NULL
7252 };
7253
7254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7256 if (SWIG_arg_fail(1)) SWIG_fail;
7257 result = (double) ((arg1)->m_x);
7258
7259 {
7260 resultobj = SWIG_From_double((double)(result));
7261 }
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7269 PyObject *resultobj;
7270 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7271 double arg2 ;
7272 PyObject * obj0 = 0 ;
7273 PyObject * obj1 = 0 ;
7274 char *kwnames[] = {
7275 (char *) "self",(char *) "m_y", NULL
7276 };
7277
7278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7280 if (SWIG_arg_fail(1)) SWIG_fail;
7281 {
7282 arg2 = (double)(SWIG_As_double(obj1));
7283 if (SWIG_arg_fail(2)) SWIG_fail;
7284 }
7285 if (arg1) (arg1)->m_y = arg2;
7286
7287 Py_INCREF(Py_None); resultobj = Py_None;
7288 return resultobj;
7289 fail:
7290 return NULL;
7291 }
7292
7293
7294 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj;
7296 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7297 double result;
7298 PyObject * obj0 = 0 ;
7299 char *kwnames[] = {
7300 (char *) "self", NULL
7301 };
7302
7303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7305 if (SWIG_arg_fail(1)) SWIG_fail;
7306 result = (double) ((arg1)->m_y);
7307
7308 {
7309 resultobj = SWIG_From_double((double)(result));
7310 }
7311 return resultobj;
7312 fail:
7313 return NULL;
7314 }
7315
7316
7317 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7318 PyObject *resultobj;
7319 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7320 double arg2 = (double) 0 ;
7321 double arg3 = (double) 0 ;
7322 PyObject * obj0 = 0 ;
7323 PyObject * obj1 = 0 ;
7324 PyObject * obj2 = 0 ;
7325 char *kwnames[] = {
7326 (char *) "self",(char *) "x",(char *) "y", NULL
7327 };
7328
7329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7331 if (SWIG_arg_fail(1)) SWIG_fail;
7332 if (obj1) {
7333 {
7334 arg2 = (double)(SWIG_As_double(obj1));
7335 if (SWIG_arg_fail(2)) SWIG_fail;
7336 }
7337 }
7338 if (obj2) {
7339 {
7340 arg3 = (double)(SWIG_As_double(obj2));
7341 if (SWIG_arg_fail(3)) SWIG_fail;
7342 }
7343 }
7344 {
7345 PyThreadState* __tstate = wxPyBeginAllowThreads();
7346 wxPoint2D_Set(arg1,arg2,arg3);
7347
7348 wxPyEndAllowThreads(__tstate);
7349 if (PyErr_Occurred()) SWIG_fail;
7350 }
7351 Py_INCREF(Py_None); resultobj = Py_None;
7352 return resultobj;
7353 fail:
7354 return NULL;
7355 }
7356
7357
7358 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7359 PyObject *resultobj;
7360 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7361 PyObject *result;
7362 PyObject * obj0 = 0 ;
7363 char *kwnames[] = {
7364 (char *) "self", NULL
7365 };
7366
7367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7369 if (SWIG_arg_fail(1)) SWIG_fail;
7370 {
7371 PyThreadState* __tstate = wxPyBeginAllowThreads();
7372 result = (PyObject *)wxPoint2D_Get(arg1);
7373
7374 wxPyEndAllowThreads(__tstate);
7375 if (PyErr_Occurred()) SWIG_fail;
7376 }
7377 resultobj = result;
7378 return resultobj;
7379 fail:
7380 return NULL;
7381 }
7382
7383
7384 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7385 PyObject *obj;
7386 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7387 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7388 Py_INCREF(obj);
7389 return Py_BuildValue((char *)"");
7390 }
7391 static int _wrap_DefaultPosition_set(PyObject *) {
7392 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7393 return 1;
7394 }
7395
7396
7397 static PyObject *_wrap_DefaultPosition_get(void) {
7398 PyObject *pyobj;
7399
7400 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7401 return pyobj;
7402 }
7403
7404
7405 static int _wrap_DefaultSize_set(PyObject *) {
7406 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7407 return 1;
7408 }
7409
7410
7411 static PyObject *_wrap_DefaultSize_get(void) {
7412 PyObject *pyobj;
7413
7414 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7415 return pyobj;
7416 }
7417
7418
7419 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7420 PyObject *resultobj;
7421 PyObject *arg1 = (PyObject *) 0 ;
7422 wxPyInputStream *result;
7423 PyObject * obj0 = 0 ;
7424 char *kwnames[] = {
7425 (char *) "p", NULL
7426 };
7427
7428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7429 arg1 = obj0;
7430 {
7431 PyThreadState* __tstate = wxPyBeginAllowThreads();
7432 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7433
7434 wxPyEndAllowThreads(__tstate);
7435 if (PyErr_Occurred()) SWIG_fail;
7436 }
7437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7438 return resultobj;
7439 fail:
7440 return NULL;
7441 }
7442
7443
7444 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7445 PyObject *resultobj;
7446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7447 PyObject * obj0 = 0 ;
7448 char *kwnames[] = {
7449 (char *) "self", NULL
7450 };
7451
7452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7454 if (SWIG_arg_fail(1)) SWIG_fail;
7455 {
7456 PyThreadState* __tstate = wxPyBeginAllowThreads();
7457 delete arg1;
7458
7459 wxPyEndAllowThreads(__tstate);
7460 if (PyErr_Occurred()) SWIG_fail;
7461 }
7462 Py_INCREF(Py_None); resultobj = Py_None;
7463 return resultobj;
7464 fail:
7465 return NULL;
7466 }
7467
7468
7469 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7470 PyObject *resultobj;
7471 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7472 PyObject * obj0 = 0 ;
7473 char *kwnames[] = {
7474 (char *) "self", NULL
7475 };
7476
7477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7479 if (SWIG_arg_fail(1)) SWIG_fail;
7480 {
7481 PyThreadState* __tstate = wxPyBeginAllowThreads();
7482 (arg1)->close();
7483
7484 wxPyEndAllowThreads(__tstate);
7485 if (PyErr_Occurred()) SWIG_fail;
7486 }
7487 Py_INCREF(Py_None); resultobj = Py_None;
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7495 PyObject *resultobj;
7496 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7497 PyObject * obj0 = 0 ;
7498 char *kwnames[] = {
7499 (char *) "self", NULL
7500 };
7501
7502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7504 if (SWIG_arg_fail(1)) SWIG_fail;
7505 {
7506 PyThreadState* __tstate = wxPyBeginAllowThreads();
7507 (arg1)->flush();
7508
7509 wxPyEndAllowThreads(__tstate);
7510 if (PyErr_Occurred()) SWIG_fail;
7511 }
7512 Py_INCREF(Py_None); resultobj = Py_None;
7513 return resultobj;
7514 fail:
7515 return NULL;
7516 }
7517
7518
7519 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7520 PyObject *resultobj;
7521 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7522 bool result;
7523 PyObject * obj0 = 0 ;
7524 char *kwnames[] = {
7525 (char *) "self", NULL
7526 };
7527
7528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7530 if (SWIG_arg_fail(1)) SWIG_fail;
7531 {
7532 PyThreadState* __tstate = wxPyBeginAllowThreads();
7533 result = (bool)(arg1)->eof();
7534
7535 wxPyEndAllowThreads(__tstate);
7536 if (PyErr_Occurred()) SWIG_fail;
7537 }
7538 {
7539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7540 }
7541 return resultobj;
7542 fail:
7543 return NULL;
7544 }
7545
7546
7547 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7548 PyObject *resultobj;
7549 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7550 int arg2 = (int) -1 ;
7551 PyObject *result;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 char *kwnames[] = {
7555 (char *) "self",(char *) "size", NULL
7556 };
7557
7558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7560 if (SWIG_arg_fail(1)) SWIG_fail;
7561 if (obj1) {
7562 {
7563 arg2 = (int)(SWIG_As_int(obj1));
7564 if (SWIG_arg_fail(2)) SWIG_fail;
7565 }
7566 }
7567 {
7568 PyThreadState* __tstate = wxPyBeginAllowThreads();
7569 result = (PyObject *)(arg1)->read(arg2);
7570
7571 wxPyEndAllowThreads(__tstate);
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 resultobj = result;
7575 return resultobj;
7576 fail:
7577 return NULL;
7578 }
7579
7580
7581 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7582 PyObject *resultobj;
7583 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7584 int arg2 = (int) -1 ;
7585 PyObject *result;
7586 PyObject * obj0 = 0 ;
7587 PyObject * obj1 = 0 ;
7588 char *kwnames[] = {
7589 (char *) "self",(char *) "size", NULL
7590 };
7591
7592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7594 if (SWIG_arg_fail(1)) SWIG_fail;
7595 if (obj1) {
7596 {
7597 arg2 = (int)(SWIG_As_int(obj1));
7598 if (SWIG_arg_fail(2)) SWIG_fail;
7599 }
7600 }
7601 {
7602 PyThreadState* __tstate = wxPyBeginAllowThreads();
7603 result = (PyObject *)(arg1)->readline(arg2);
7604
7605 wxPyEndAllowThreads(__tstate);
7606 if (PyErr_Occurred()) SWIG_fail;
7607 }
7608 resultobj = result;
7609 return resultobj;
7610 fail:
7611 return NULL;
7612 }
7613
7614
7615 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7616 PyObject *resultobj;
7617 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7618 int arg2 = (int) -1 ;
7619 PyObject *result;
7620 PyObject * obj0 = 0 ;
7621 PyObject * obj1 = 0 ;
7622 char *kwnames[] = {
7623 (char *) "self",(char *) "sizehint", NULL
7624 };
7625
7626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7628 if (SWIG_arg_fail(1)) SWIG_fail;
7629 if (obj1) {
7630 {
7631 arg2 = (int)(SWIG_As_int(obj1));
7632 if (SWIG_arg_fail(2)) SWIG_fail;
7633 }
7634 }
7635 {
7636 PyThreadState* __tstate = wxPyBeginAllowThreads();
7637 result = (PyObject *)(arg1)->readlines(arg2);
7638
7639 wxPyEndAllowThreads(__tstate);
7640 if (PyErr_Occurred()) SWIG_fail;
7641 }
7642 resultobj = result;
7643 return resultobj;
7644 fail:
7645 return NULL;
7646 }
7647
7648
7649 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7650 PyObject *resultobj;
7651 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7652 int arg2 ;
7653 int arg3 = (int) 0 ;
7654 PyObject * obj0 = 0 ;
7655 PyObject * obj1 = 0 ;
7656 PyObject * obj2 = 0 ;
7657 char *kwnames[] = {
7658 (char *) "self",(char *) "offset",(char *) "whence", NULL
7659 };
7660
7661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7663 if (SWIG_arg_fail(1)) SWIG_fail;
7664 {
7665 arg2 = (int)(SWIG_As_int(obj1));
7666 if (SWIG_arg_fail(2)) SWIG_fail;
7667 }
7668 if (obj2) {
7669 {
7670 arg3 = (int)(SWIG_As_int(obj2));
7671 if (SWIG_arg_fail(3)) SWIG_fail;
7672 }
7673 }
7674 {
7675 PyThreadState* __tstate = wxPyBeginAllowThreads();
7676 (arg1)->seek(arg2,arg3);
7677
7678 wxPyEndAllowThreads(__tstate);
7679 if (PyErr_Occurred()) SWIG_fail;
7680 }
7681 Py_INCREF(Py_None); resultobj = Py_None;
7682 return resultobj;
7683 fail:
7684 return NULL;
7685 }
7686
7687
7688 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7689 PyObject *resultobj;
7690 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7691 int result;
7692 PyObject * obj0 = 0 ;
7693 char *kwnames[] = {
7694 (char *) "self", NULL
7695 };
7696
7697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7699 if (SWIG_arg_fail(1)) SWIG_fail;
7700 {
7701 PyThreadState* __tstate = wxPyBeginAllowThreads();
7702 result = (int)(arg1)->tell();
7703
7704 wxPyEndAllowThreads(__tstate);
7705 if (PyErr_Occurred()) SWIG_fail;
7706 }
7707 {
7708 resultobj = SWIG_From_int((int)(result));
7709 }
7710 return resultobj;
7711 fail:
7712 return NULL;
7713 }
7714
7715
7716 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7717 PyObject *resultobj;
7718 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7719 char result;
7720 PyObject * obj0 = 0 ;
7721 char *kwnames[] = {
7722 (char *) "self", NULL
7723 };
7724
7725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7727 if (SWIG_arg_fail(1)) SWIG_fail;
7728 {
7729 PyThreadState* __tstate = wxPyBeginAllowThreads();
7730 result = (char)(arg1)->Peek();
7731
7732 wxPyEndAllowThreads(__tstate);
7733 if (PyErr_Occurred()) SWIG_fail;
7734 }
7735 {
7736 resultobj = SWIG_From_char((char)(result));
7737 }
7738 return resultobj;
7739 fail:
7740 return NULL;
7741 }
7742
7743
7744 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7745 PyObject *resultobj;
7746 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7747 char result;
7748 PyObject * obj0 = 0 ;
7749 char *kwnames[] = {
7750 (char *) "self", NULL
7751 };
7752
7753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7755 if (SWIG_arg_fail(1)) SWIG_fail;
7756 {
7757 PyThreadState* __tstate = wxPyBeginAllowThreads();
7758 result = (char)(arg1)->GetC();
7759
7760 wxPyEndAllowThreads(__tstate);
7761 if (PyErr_Occurred()) SWIG_fail;
7762 }
7763 {
7764 resultobj = SWIG_From_char((char)(result));
7765 }
7766 return resultobj;
7767 fail:
7768 return NULL;
7769 }
7770
7771
7772 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7773 PyObject *resultobj;
7774 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7775 size_t result;
7776 PyObject * obj0 = 0 ;
7777 char *kwnames[] = {
7778 (char *) "self", NULL
7779 };
7780
7781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7783 if (SWIG_arg_fail(1)) SWIG_fail;
7784 {
7785 PyThreadState* __tstate = wxPyBeginAllowThreads();
7786 result = (size_t)(arg1)->LastRead();
7787
7788 wxPyEndAllowThreads(__tstate);
7789 if (PyErr_Occurred()) SWIG_fail;
7790 }
7791 {
7792 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7793 }
7794 return resultobj;
7795 fail:
7796 return NULL;
7797 }
7798
7799
7800 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7801 PyObject *resultobj;
7802 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7803 bool result;
7804 PyObject * obj0 = 0 ;
7805 char *kwnames[] = {
7806 (char *) "self", NULL
7807 };
7808
7809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7811 if (SWIG_arg_fail(1)) SWIG_fail;
7812 {
7813 PyThreadState* __tstate = wxPyBeginAllowThreads();
7814 result = (bool)(arg1)->CanRead();
7815
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 {
7820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7821 }
7822 return resultobj;
7823 fail:
7824 return NULL;
7825 }
7826
7827
7828 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7829 PyObject *resultobj;
7830 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7831 bool result;
7832 PyObject * obj0 = 0 ;
7833 char *kwnames[] = {
7834 (char *) "self", NULL
7835 };
7836
7837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7839 if (SWIG_arg_fail(1)) SWIG_fail;
7840 {
7841 PyThreadState* __tstate = wxPyBeginAllowThreads();
7842 result = (bool)(arg1)->Eof();
7843
7844 wxPyEndAllowThreads(__tstate);
7845 if (PyErr_Occurred()) SWIG_fail;
7846 }
7847 {
7848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7849 }
7850 return resultobj;
7851 fail:
7852 return NULL;
7853 }
7854
7855
7856 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7857 PyObject *resultobj;
7858 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7859 char arg2 ;
7860 bool result;
7861 PyObject * obj0 = 0 ;
7862 PyObject * obj1 = 0 ;
7863 char *kwnames[] = {
7864 (char *) "self",(char *) "c", NULL
7865 };
7866
7867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7869 if (SWIG_arg_fail(1)) SWIG_fail;
7870 {
7871 arg2 = (char)(SWIG_As_char(obj1));
7872 if (SWIG_arg_fail(2)) SWIG_fail;
7873 }
7874 {
7875 PyThreadState* __tstate = wxPyBeginAllowThreads();
7876 result = (bool)(arg1)->Ungetch(arg2);
7877
7878 wxPyEndAllowThreads(__tstate);
7879 if (PyErr_Occurred()) SWIG_fail;
7880 }
7881 {
7882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7883 }
7884 return resultobj;
7885 fail:
7886 return NULL;
7887 }
7888
7889
7890 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7891 PyObject *resultobj;
7892 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7893 long arg2 ;
7894 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7895 long result;
7896 PyObject * obj0 = 0 ;
7897 PyObject * obj1 = 0 ;
7898 PyObject * obj2 = 0 ;
7899 char *kwnames[] = {
7900 (char *) "self",(char *) "pos",(char *) "mode", NULL
7901 };
7902
7903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7905 if (SWIG_arg_fail(1)) SWIG_fail;
7906 {
7907 arg2 = (long)(SWIG_As_long(obj1));
7908 if (SWIG_arg_fail(2)) SWIG_fail;
7909 }
7910 if (obj2) {
7911 {
7912 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7913 if (SWIG_arg_fail(3)) SWIG_fail;
7914 }
7915 }
7916 {
7917 PyThreadState* __tstate = wxPyBeginAllowThreads();
7918 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7919
7920 wxPyEndAllowThreads(__tstate);
7921 if (PyErr_Occurred()) SWIG_fail;
7922 }
7923 {
7924 resultobj = SWIG_From_long((long)(result));
7925 }
7926 return resultobj;
7927 fail:
7928 return NULL;
7929 }
7930
7931
7932 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7933 PyObject *resultobj;
7934 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7935 long result;
7936 PyObject * obj0 = 0 ;
7937 char *kwnames[] = {
7938 (char *) "self", NULL
7939 };
7940
7941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7943 if (SWIG_arg_fail(1)) SWIG_fail;
7944 {
7945 PyThreadState* __tstate = wxPyBeginAllowThreads();
7946 result = (long)(arg1)->TellI();
7947
7948 wxPyEndAllowThreads(__tstate);
7949 if (PyErr_Occurred()) SWIG_fail;
7950 }
7951 {
7952 resultobj = SWIG_From_long((long)(result));
7953 }
7954 return resultobj;
7955 fail:
7956 return NULL;
7957 }
7958
7959
7960 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7961 PyObject *obj;
7962 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7963 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7964 Py_INCREF(obj);
7965 return Py_BuildValue((char *)"");
7966 }
7967 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7968 PyObject *resultobj;
7969 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7970 PyObject *arg2 = (PyObject *) 0 ;
7971 PyObject * obj0 = 0 ;
7972 PyObject * obj1 = 0 ;
7973 char *kwnames[] = {
7974 (char *) "self",(char *) "obj", NULL
7975 };
7976
7977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7979 if (SWIG_arg_fail(1)) SWIG_fail;
7980 arg2 = obj1;
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 wxOutputStream_write(arg1,arg2);
7984
7985 wxPyEndAllowThreads(__tstate);
7986 if (PyErr_Occurred()) SWIG_fail;
7987 }
7988 Py_INCREF(Py_None); resultobj = Py_None;
7989 return resultobj;
7990 fail:
7991 return NULL;
7992 }
7993
7994
7995 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7996 PyObject *obj;
7997 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7998 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7999 Py_INCREF(obj);
8000 return Py_BuildValue((char *)"");
8001 }
8002 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8003 PyObject *resultobj;
8004 wxInputStream *arg1 = (wxInputStream *) 0 ;
8005 wxString *arg2 = 0 ;
8006 wxString *arg3 = 0 ;
8007 wxString *arg4 = 0 ;
8008 wxDateTime arg5 ;
8009 wxFSFile *result;
8010 wxPyInputStream *temp1 ;
8011 bool temp2 = false ;
8012 bool temp3 = false ;
8013 bool temp4 = false ;
8014 PyObject * obj0 = 0 ;
8015 PyObject * obj1 = 0 ;
8016 PyObject * obj2 = 0 ;
8017 PyObject * obj3 = 0 ;
8018 PyObject * obj4 = 0 ;
8019 char *kwnames[] = {
8020 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
8021 };
8022
8023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
8024 {
8025 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
8026 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8027 } else {
8028 PyErr_Clear(); // clear the failure of the wxPyConvert above
8029 arg1 = wxPyCBInputStream_create(obj0, true);
8030 if (arg1 == NULL) {
8031 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8032 SWIG_fail;
8033 }
8034 }
8035 }
8036 {
8037 arg2 = wxString_in_helper(obj1);
8038 if (arg2 == NULL) SWIG_fail;
8039 temp2 = true;
8040 }
8041 {
8042 arg3 = wxString_in_helper(obj2);
8043 if (arg3 == NULL) SWIG_fail;
8044 temp3 = true;
8045 }
8046 {
8047 arg4 = wxString_in_helper(obj3);
8048 if (arg4 == NULL) SWIG_fail;
8049 temp4 = true;
8050 }
8051 {
8052 wxDateTime * argp;
8053 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8054 if (SWIG_arg_fail(5)) SWIG_fail;
8055 if (argp == NULL) {
8056 SWIG_null_ref("wxDateTime");
8057 }
8058 if (SWIG_arg_fail(5)) SWIG_fail;
8059 arg5 = *argp;
8060 }
8061 {
8062 PyThreadState* __tstate = wxPyBeginAllowThreads();
8063 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8064
8065 wxPyEndAllowThreads(__tstate);
8066 if (PyErr_Occurred()) SWIG_fail;
8067 }
8068 {
8069 resultobj = wxPyMake_wxObject(result, 1);
8070 }
8071 {
8072 if (temp2)
8073 delete arg2;
8074 }
8075 {
8076 if (temp3)
8077 delete arg3;
8078 }
8079 {
8080 if (temp4)
8081 delete arg4;
8082 }
8083 return resultobj;
8084 fail:
8085 {
8086 if (temp2)
8087 delete arg2;
8088 }
8089 {
8090 if (temp3)
8091 delete arg3;
8092 }
8093 {
8094 if (temp4)
8095 delete arg4;
8096 }
8097 return NULL;
8098 }
8099
8100
8101 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8102 PyObject *resultobj;
8103 wxFSFile *arg1 = (wxFSFile *) 0 ;
8104 PyObject * obj0 = 0 ;
8105 char *kwnames[] = {
8106 (char *) "self", NULL
8107 };
8108
8109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8111 if (SWIG_arg_fail(1)) SWIG_fail;
8112 {
8113 PyThreadState* __tstate = wxPyBeginAllowThreads();
8114 delete arg1;
8115
8116 wxPyEndAllowThreads(__tstate);
8117 if (PyErr_Occurred()) SWIG_fail;
8118 }
8119 Py_INCREF(Py_None); resultobj = Py_None;
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8127 PyObject *resultobj;
8128 wxFSFile *arg1 = (wxFSFile *) 0 ;
8129 wxInputStream *result;
8130 PyObject * obj0 = 0 ;
8131 char *kwnames[] = {
8132 (char *) "self", NULL
8133 };
8134
8135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8137 if (SWIG_arg_fail(1)) SWIG_fail;
8138 {
8139 PyThreadState* __tstate = wxPyBeginAllowThreads();
8140 result = (wxInputStream *)(arg1)->GetStream();
8141
8142 wxPyEndAllowThreads(__tstate);
8143 if (PyErr_Occurred()) SWIG_fail;
8144 }
8145 {
8146 wxPyInputStream * _ptr = NULL;
8147
8148 if (result) {
8149 _ptr = new wxPyInputStream(result);
8150 }
8151 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8152 }
8153 return resultobj;
8154 fail:
8155 return NULL;
8156 }
8157
8158
8159 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8160 PyObject *resultobj;
8161 wxFSFile *arg1 = (wxFSFile *) 0 ;
8162 wxString *result;
8163 PyObject * obj0 = 0 ;
8164 char *kwnames[] = {
8165 (char *) "self", NULL
8166 };
8167
8168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8170 if (SWIG_arg_fail(1)) SWIG_fail;
8171 {
8172 PyThreadState* __tstate = wxPyBeginAllowThreads();
8173 {
8174 wxString const &_result_ref = (arg1)->GetMimeType();
8175 result = (wxString *) &_result_ref;
8176 }
8177
8178 wxPyEndAllowThreads(__tstate);
8179 if (PyErr_Occurred()) SWIG_fail;
8180 }
8181 {
8182 #if wxUSE_UNICODE
8183 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8184 #else
8185 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8186 #endif
8187 }
8188 return resultobj;
8189 fail:
8190 return NULL;
8191 }
8192
8193
8194 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8195 PyObject *resultobj;
8196 wxFSFile *arg1 = (wxFSFile *) 0 ;
8197 wxString *result;
8198 PyObject * obj0 = 0 ;
8199 char *kwnames[] = {
8200 (char *) "self", NULL
8201 };
8202
8203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8205 if (SWIG_arg_fail(1)) SWIG_fail;
8206 {
8207 PyThreadState* __tstate = wxPyBeginAllowThreads();
8208 {
8209 wxString const &_result_ref = (arg1)->GetLocation();
8210 result = (wxString *) &_result_ref;
8211 }
8212
8213 wxPyEndAllowThreads(__tstate);
8214 if (PyErr_Occurred()) SWIG_fail;
8215 }
8216 {
8217 #if wxUSE_UNICODE
8218 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8219 #else
8220 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8221 #endif
8222 }
8223 return resultobj;
8224 fail:
8225 return NULL;
8226 }
8227
8228
8229 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8230 PyObject *resultobj;
8231 wxFSFile *arg1 = (wxFSFile *) 0 ;
8232 wxString *result;
8233 PyObject * obj0 = 0 ;
8234 char *kwnames[] = {
8235 (char *) "self", NULL
8236 };
8237
8238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8240 if (SWIG_arg_fail(1)) SWIG_fail;
8241 {
8242 PyThreadState* __tstate = wxPyBeginAllowThreads();
8243 {
8244 wxString const &_result_ref = (arg1)->GetAnchor();
8245 result = (wxString *) &_result_ref;
8246 }
8247
8248 wxPyEndAllowThreads(__tstate);
8249 if (PyErr_Occurred()) SWIG_fail;
8250 }
8251 {
8252 #if wxUSE_UNICODE
8253 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8254 #else
8255 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8256 #endif
8257 }
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj;
8266 wxFSFile *arg1 = (wxFSFile *) 0 ;
8267 wxDateTime result;
8268 PyObject * obj0 = 0 ;
8269 char *kwnames[] = {
8270 (char *) "self", NULL
8271 };
8272
8273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8275 if (SWIG_arg_fail(1)) SWIG_fail;
8276 {
8277 PyThreadState* __tstate = wxPyBeginAllowThreads();
8278 result = (arg1)->GetModificationTime();
8279
8280 wxPyEndAllowThreads(__tstate);
8281 if (PyErr_Occurred()) SWIG_fail;
8282 }
8283 {
8284 wxDateTime * resultptr;
8285 resultptr = new wxDateTime((wxDateTime &)(result));
8286 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8287 }
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8295 PyObject *obj;
8296 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8297 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8298 Py_INCREF(obj);
8299 return Py_BuildValue((char *)"");
8300 }
8301 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8302 PyObject *obj;
8303 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8304 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8305 Py_INCREF(obj);
8306 return Py_BuildValue((char *)"");
8307 }
8308 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8309 PyObject *resultobj;
8310 wxPyFileSystemHandler *result;
8311 char *kwnames[] = {
8312 NULL
8313 };
8314
8315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8316 {
8317 PyThreadState* __tstate = wxPyBeginAllowThreads();
8318 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8319
8320 wxPyEndAllowThreads(__tstate);
8321 if (PyErr_Occurred()) SWIG_fail;
8322 }
8323 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8324 return resultobj;
8325 fail:
8326 return NULL;
8327 }
8328
8329
8330 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8331 PyObject *resultobj;
8332 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8333 PyObject *arg2 = (PyObject *) 0 ;
8334 PyObject *arg3 = (PyObject *) 0 ;
8335 PyObject * obj0 = 0 ;
8336 PyObject * obj1 = 0 ;
8337 PyObject * obj2 = 0 ;
8338 char *kwnames[] = {
8339 (char *) "self",(char *) "self",(char *) "_class", NULL
8340 };
8341
8342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8344 if (SWIG_arg_fail(1)) SWIG_fail;
8345 arg2 = obj1;
8346 arg3 = obj2;
8347 {
8348 PyThreadState* __tstate = wxPyBeginAllowThreads();
8349 (arg1)->_setCallbackInfo(arg2,arg3);
8350
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 Py_INCREF(Py_None); resultobj = Py_None;
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj;
8363 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8364 wxString *arg2 = 0 ;
8365 bool result;
8366 bool temp2 = false ;
8367 PyObject * obj0 = 0 ;
8368 PyObject * obj1 = 0 ;
8369 char *kwnames[] = {
8370 (char *) "self",(char *) "location", NULL
8371 };
8372
8373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8375 if (SWIG_arg_fail(1)) SWIG_fail;
8376 {
8377 arg2 = wxString_in_helper(obj1);
8378 if (arg2 == NULL) SWIG_fail;
8379 temp2 = true;
8380 }
8381 {
8382 PyThreadState* __tstate = wxPyBeginAllowThreads();
8383 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8384
8385 wxPyEndAllowThreads(__tstate);
8386 if (PyErr_Occurred()) SWIG_fail;
8387 }
8388 {
8389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8390 }
8391 {
8392 if (temp2)
8393 delete arg2;
8394 }
8395 return resultobj;
8396 fail:
8397 {
8398 if (temp2)
8399 delete arg2;
8400 }
8401 return NULL;
8402 }
8403
8404
8405 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8406 PyObject *resultobj;
8407 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8408 wxFileSystem *arg2 = 0 ;
8409 wxString *arg3 = 0 ;
8410 wxFSFile *result;
8411 bool temp3 = false ;
8412 PyObject * obj0 = 0 ;
8413 PyObject * obj1 = 0 ;
8414 PyObject * obj2 = 0 ;
8415 char *kwnames[] = {
8416 (char *) "self",(char *) "fs",(char *) "location", NULL
8417 };
8418
8419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8421 if (SWIG_arg_fail(1)) SWIG_fail;
8422 {
8423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8424 if (SWIG_arg_fail(2)) SWIG_fail;
8425 if (arg2 == NULL) {
8426 SWIG_null_ref("wxFileSystem");
8427 }
8428 if (SWIG_arg_fail(2)) SWIG_fail;
8429 }
8430 {
8431 arg3 = wxString_in_helper(obj2);
8432 if (arg3 == NULL) SWIG_fail;
8433 temp3 = true;
8434 }
8435 {
8436 PyThreadState* __tstate = wxPyBeginAllowThreads();
8437 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8438
8439 wxPyEndAllowThreads(__tstate);
8440 if (PyErr_Occurred()) SWIG_fail;
8441 }
8442 {
8443 resultobj = wxPyMake_wxObject(result, 1);
8444 }
8445 {
8446 if (temp3)
8447 delete arg3;
8448 }
8449 return resultobj;
8450 fail:
8451 {
8452 if (temp3)
8453 delete arg3;
8454 }
8455 return NULL;
8456 }
8457
8458
8459 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8460 PyObject *resultobj;
8461 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8462 wxString *arg2 = 0 ;
8463 int arg3 = (int) 0 ;
8464 wxString result;
8465 bool temp2 = false ;
8466 PyObject * obj0 = 0 ;
8467 PyObject * obj1 = 0 ;
8468 PyObject * obj2 = 0 ;
8469 char *kwnames[] = {
8470 (char *) "self",(char *) "spec",(char *) "flags", NULL
8471 };
8472
8473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8475 if (SWIG_arg_fail(1)) SWIG_fail;
8476 {
8477 arg2 = wxString_in_helper(obj1);
8478 if (arg2 == NULL) SWIG_fail;
8479 temp2 = true;
8480 }
8481 if (obj2) {
8482 {
8483 arg3 = (int)(SWIG_As_int(obj2));
8484 if (SWIG_arg_fail(3)) SWIG_fail;
8485 }
8486 }
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8490
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 {
8495 #if wxUSE_UNICODE
8496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8497 #else
8498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8499 #endif
8500 }
8501 {
8502 if (temp2)
8503 delete arg2;
8504 }
8505 return resultobj;
8506 fail:
8507 {
8508 if (temp2)
8509 delete arg2;
8510 }
8511 return NULL;
8512 }
8513
8514
8515 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8516 PyObject *resultobj;
8517 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8518 wxString result;
8519 PyObject * obj0 = 0 ;
8520 char *kwnames[] = {
8521 (char *) "self", NULL
8522 };
8523
8524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8526 if (SWIG_arg_fail(1)) SWIG_fail;
8527 {
8528 PyThreadState* __tstate = wxPyBeginAllowThreads();
8529 result = (arg1)->FindNext();
8530
8531 wxPyEndAllowThreads(__tstate);
8532 if (PyErr_Occurred()) SWIG_fail;
8533 }
8534 {
8535 #if wxUSE_UNICODE
8536 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8537 #else
8538 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8539 #endif
8540 }
8541 return resultobj;
8542 fail:
8543 return NULL;
8544 }
8545
8546
8547 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8548 PyObject *resultobj;
8549 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8550 wxString *arg2 = 0 ;
8551 wxString result;
8552 bool temp2 = false ;
8553 PyObject * obj0 = 0 ;
8554 PyObject * obj1 = 0 ;
8555 char *kwnames[] = {
8556 (char *) "self",(char *) "location", NULL
8557 };
8558
8559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8561 if (SWIG_arg_fail(1)) SWIG_fail;
8562 {
8563 arg2 = wxString_in_helper(obj1);
8564 if (arg2 == NULL) SWIG_fail;
8565 temp2 = true;
8566 }
8567 {
8568 PyThreadState* __tstate = wxPyBeginAllowThreads();
8569 result = (arg1)->GetProtocol((wxString const &)*arg2);
8570
8571 wxPyEndAllowThreads(__tstate);
8572 if (PyErr_Occurred()) SWIG_fail;
8573 }
8574 {
8575 #if wxUSE_UNICODE
8576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8577 #else
8578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8579 #endif
8580 }
8581 {
8582 if (temp2)
8583 delete arg2;
8584 }
8585 return resultobj;
8586 fail:
8587 {
8588 if (temp2)
8589 delete arg2;
8590 }
8591 return NULL;
8592 }
8593
8594
8595 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8596 PyObject *resultobj;
8597 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8598 wxString *arg2 = 0 ;
8599 wxString result;
8600 bool temp2 = false ;
8601 PyObject * obj0 = 0 ;
8602 PyObject * obj1 = 0 ;
8603 char *kwnames[] = {
8604 (char *) "self",(char *) "location", NULL
8605 };
8606
8607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8609 if (SWIG_arg_fail(1)) SWIG_fail;
8610 {
8611 arg2 = wxString_in_helper(obj1);
8612 if (arg2 == NULL) SWIG_fail;
8613 temp2 = true;
8614 }
8615 {
8616 PyThreadState* __tstate = wxPyBeginAllowThreads();
8617 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8618
8619 wxPyEndAllowThreads(__tstate);
8620 if (PyErr_Occurred()) SWIG_fail;
8621 }
8622 {
8623 #if wxUSE_UNICODE
8624 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8625 #else
8626 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8627 #endif
8628 }
8629 {
8630 if (temp2)
8631 delete arg2;
8632 }
8633 return resultobj;
8634 fail:
8635 {
8636 if (temp2)
8637 delete arg2;
8638 }
8639 return NULL;
8640 }
8641
8642
8643 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8644 PyObject *resultobj;
8645 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8646 wxString *arg2 = 0 ;
8647 wxString result;
8648 bool temp2 = false ;
8649 PyObject * obj0 = 0 ;
8650 PyObject * obj1 = 0 ;
8651 char *kwnames[] = {
8652 (char *) "self",(char *) "location", NULL
8653 };
8654
8655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8657 if (SWIG_arg_fail(1)) SWIG_fail;
8658 {
8659 arg2 = wxString_in_helper(obj1);
8660 if (arg2 == NULL) SWIG_fail;
8661 temp2 = true;
8662 }
8663 {
8664 PyThreadState* __tstate = wxPyBeginAllowThreads();
8665 result = (arg1)->GetAnchor((wxString const &)*arg2);
8666
8667 wxPyEndAllowThreads(__tstate);
8668 if (PyErr_Occurred()) SWIG_fail;
8669 }
8670 {
8671 #if wxUSE_UNICODE
8672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8673 #else
8674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8675 #endif
8676 }
8677 {
8678 if (temp2)
8679 delete arg2;
8680 }
8681 return resultobj;
8682 fail:
8683 {
8684 if (temp2)
8685 delete arg2;
8686 }
8687 return NULL;
8688 }
8689
8690
8691 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8692 PyObject *resultobj;
8693 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8694 wxString *arg2 = 0 ;
8695 wxString result;
8696 bool temp2 = false ;
8697 PyObject * obj0 = 0 ;
8698 PyObject * obj1 = 0 ;
8699 char *kwnames[] = {
8700 (char *) "self",(char *) "location", NULL
8701 };
8702
8703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8705 if (SWIG_arg_fail(1)) SWIG_fail;
8706 {
8707 arg2 = wxString_in_helper(obj1);
8708 if (arg2 == NULL) SWIG_fail;
8709 temp2 = true;
8710 }
8711 {
8712 PyThreadState* __tstate = wxPyBeginAllowThreads();
8713 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8714
8715 wxPyEndAllowThreads(__tstate);
8716 if (PyErr_Occurred()) SWIG_fail;
8717 }
8718 {
8719 #if wxUSE_UNICODE
8720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8721 #else
8722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8723 #endif
8724 }
8725 {
8726 if (temp2)
8727 delete arg2;
8728 }
8729 return resultobj;
8730 fail:
8731 {
8732 if (temp2)
8733 delete arg2;
8734 }
8735 return NULL;
8736 }
8737
8738
8739 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8740 PyObject *resultobj;
8741 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8742 wxString *arg2 = 0 ;
8743 wxString result;
8744 bool temp2 = false ;
8745 PyObject * obj0 = 0 ;
8746 PyObject * obj1 = 0 ;
8747 char *kwnames[] = {
8748 (char *) "self",(char *) "location", NULL
8749 };
8750
8751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8753 if (SWIG_arg_fail(1)) SWIG_fail;
8754 {
8755 arg2 = wxString_in_helper(obj1);
8756 if (arg2 == NULL) SWIG_fail;
8757 temp2 = true;
8758 }
8759 {
8760 PyThreadState* __tstate = wxPyBeginAllowThreads();
8761 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8762
8763 wxPyEndAllowThreads(__tstate);
8764 if (PyErr_Occurred()) SWIG_fail;
8765 }
8766 {
8767 #if wxUSE_UNICODE
8768 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8769 #else
8770 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8771 #endif
8772 }
8773 {
8774 if (temp2)
8775 delete arg2;
8776 }
8777 return resultobj;
8778 fail:
8779 {
8780 if (temp2)
8781 delete arg2;
8782 }
8783 return NULL;
8784 }
8785
8786
8787 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8788 PyObject *obj;
8789 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8790 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8791 Py_INCREF(obj);
8792 return Py_BuildValue((char *)"");
8793 }
8794 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8795 PyObject *resultobj;
8796 wxFileSystem *result;
8797 char *kwnames[] = {
8798 NULL
8799 };
8800
8801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8802 {
8803 PyThreadState* __tstate = wxPyBeginAllowThreads();
8804 result = (wxFileSystem *)new wxFileSystem();
8805
8806 wxPyEndAllowThreads(__tstate);
8807 if (PyErr_Occurred()) SWIG_fail;
8808 }
8809 {
8810 resultobj = wxPyMake_wxObject(result, 1);
8811 }
8812 return resultobj;
8813 fail:
8814 return NULL;
8815 }
8816
8817
8818 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8819 PyObject *resultobj;
8820 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8821 PyObject * obj0 = 0 ;
8822 char *kwnames[] = {
8823 (char *) "self", NULL
8824 };
8825
8826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8828 if (SWIG_arg_fail(1)) SWIG_fail;
8829 {
8830 PyThreadState* __tstate = wxPyBeginAllowThreads();
8831 delete arg1;
8832
8833 wxPyEndAllowThreads(__tstate);
8834 if (PyErr_Occurred()) SWIG_fail;
8835 }
8836 Py_INCREF(Py_None); resultobj = Py_None;
8837 return resultobj;
8838 fail:
8839 return NULL;
8840 }
8841
8842
8843 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8844 PyObject *resultobj;
8845 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8846 wxString *arg2 = 0 ;
8847 bool arg3 = (bool) false ;
8848 bool temp2 = false ;
8849 PyObject * obj0 = 0 ;
8850 PyObject * obj1 = 0 ;
8851 PyObject * obj2 = 0 ;
8852 char *kwnames[] = {
8853 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8854 };
8855
8856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = wxString_in_helper(obj1);
8861 if (arg2 == NULL) SWIG_fail;
8862 temp2 = true;
8863 }
8864 if (obj2) {
8865 {
8866 arg3 = (bool)(SWIG_As_bool(obj2));
8867 if (SWIG_arg_fail(3)) SWIG_fail;
8868 }
8869 }
8870 {
8871 PyThreadState* __tstate = wxPyBeginAllowThreads();
8872 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8873
8874 wxPyEndAllowThreads(__tstate);
8875 if (PyErr_Occurred()) SWIG_fail;
8876 }
8877 Py_INCREF(Py_None); resultobj = Py_None;
8878 {
8879 if (temp2)
8880 delete arg2;
8881 }
8882 return resultobj;
8883 fail:
8884 {
8885 if (temp2)
8886 delete arg2;
8887 }
8888 return NULL;
8889 }
8890
8891
8892 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8893 PyObject *resultobj;
8894 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8895 wxString result;
8896 PyObject * obj0 = 0 ;
8897 char *kwnames[] = {
8898 (char *) "self", NULL
8899 };
8900
8901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8903 if (SWIG_arg_fail(1)) SWIG_fail;
8904 {
8905 PyThreadState* __tstate = wxPyBeginAllowThreads();
8906 result = (arg1)->GetPath();
8907
8908 wxPyEndAllowThreads(__tstate);
8909 if (PyErr_Occurred()) SWIG_fail;
8910 }
8911 {
8912 #if wxUSE_UNICODE
8913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8914 #else
8915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8916 #endif
8917 }
8918 return resultobj;
8919 fail:
8920 return NULL;
8921 }
8922
8923
8924 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8925 PyObject *resultobj;
8926 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8927 wxString *arg2 = 0 ;
8928 wxFSFile *result;
8929 bool temp2 = false ;
8930 PyObject * obj0 = 0 ;
8931 PyObject * obj1 = 0 ;
8932 char *kwnames[] = {
8933 (char *) "self",(char *) "location", NULL
8934 };
8935
8936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8938 if (SWIG_arg_fail(1)) SWIG_fail;
8939 {
8940 arg2 = wxString_in_helper(obj1);
8941 if (arg2 == NULL) SWIG_fail;
8942 temp2 = true;
8943 }
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8947
8948 wxPyEndAllowThreads(__tstate);
8949 if (PyErr_Occurred()) SWIG_fail;
8950 }
8951 {
8952 resultobj = wxPyMake_wxObject(result, 1);
8953 }
8954 {
8955 if (temp2)
8956 delete arg2;
8957 }
8958 return resultobj;
8959 fail:
8960 {
8961 if (temp2)
8962 delete arg2;
8963 }
8964 return NULL;
8965 }
8966
8967
8968 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8969 PyObject *resultobj;
8970 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8971 wxString *arg2 = 0 ;
8972 int arg3 = (int) 0 ;
8973 wxString result;
8974 bool temp2 = false ;
8975 PyObject * obj0 = 0 ;
8976 PyObject * obj1 = 0 ;
8977 PyObject * obj2 = 0 ;
8978 char *kwnames[] = {
8979 (char *) "self",(char *) "spec",(char *) "flags", NULL
8980 };
8981
8982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8984 if (SWIG_arg_fail(1)) SWIG_fail;
8985 {
8986 arg2 = wxString_in_helper(obj1);
8987 if (arg2 == NULL) SWIG_fail;
8988 temp2 = true;
8989 }
8990 if (obj2) {
8991 {
8992 arg3 = (int)(SWIG_As_int(obj2));
8993 if (SWIG_arg_fail(3)) SWIG_fail;
8994 }
8995 }
8996 {
8997 PyThreadState* __tstate = wxPyBeginAllowThreads();
8998 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8999
9000 wxPyEndAllowThreads(__tstate);
9001 if (PyErr_Occurred()) SWIG_fail;
9002 }
9003 {
9004 #if wxUSE_UNICODE
9005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9006 #else
9007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9008 #endif
9009 }
9010 {
9011 if (temp2)
9012 delete arg2;
9013 }
9014 return resultobj;
9015 fail:
9016 {
9017 if (temp2)
9018 delete arg2;
9019 }
9020 return NULL;
9021 }
9022
9023
9024 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9025 PyObject *resultobj;
9026 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9027 wxString result;
9028 PyObject * obj0 = 0 ;
9029 char *kwnames[] = {
9030 (char *) "self", NULL
9031 };
9032
9033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9035 if (SWIG_arg_fail(1)) SWIG_fail;
9036 {
9037 PyThreadState* __tstate = wxPyBeginAllowThreads();
9038 result = (arg1)->FindNext();
9039
9040 wxPyEndAllowThreads(__tstate);
9041 if (PyErr_Occurred()) SWIG_fail;
9042 }
9043 {
9044 #if wxUSE_UNICODE
9045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9046 #else
9047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9048 #endif
9049 }
9050 return resultobj;
9051 fail:
9052 return NULL;
9053 }
9054
9055
9056 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9057 PyObject *resultobj;
9058 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9059 PyObject * obj0 = 0 ;
9060 char *kwnames[] = {
9061 (char *) "handler", NULL
9062 };
9063
9064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9066 if (SWIG_arg_fail(1)) SWIG_fail;
9067 {
9068 PyThreadState* __tstate = wxPyBeginAllowThreads();
9069 wxFileSystem::AddHandler(arg1);
9070
9071 wxPyEndAllowThreads(__tstate);
9072 if (PyErr_Occurred()) SWIG_fail;
9073 }
9074 Py_INCREF(Py_None); resultobj = Py_None;
9075 return resultobj;
9076 fail:
9077 return NULL;
9078 }
9079
9080
9081 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9082 PyObject *resultobj;
9083 char *kwnames[] = {
9084 NULL
9085 };
9086
9087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9088 {
9089 PyThreadState* __tstate = wxPyBeginAllowThreads();
9090 wxFileSystem::CleanUpHandlers();
9091
9092 wxPyEndAllowThreads(__tstate);
9093 if (PyErr_Occurred()) SWIG_fail;
9094 }
9095 Py_INCREF(Py_None); resultobj = Py_None;
9096 return resultobj;
9097 fail:
9098 return NULL;
9099 }
9100
9101
9102 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9103 PyObject *resultobj;
9104 wxString *arg1 = 0 ;
9105 wxString result;
9106 bool temp1 = false ;
9107 PyObject * obj0 = 0 ;
9108 char *kwnames[] = {
9109 (char *) "filename", NULL
9110 };
9111
9112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9113 {
9114 arg1 = wxString_in_helper(obj0);
9115 if (arg1 == NULL) SWIG_fail;
9116 temp1 = true;
9117 }
9118 {
9119 PyThreadState* __tstate = wxPyBeginAllowThreads();
9120 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9121
9122 wxPyEndAllowThreads(__tstate);
9123 if (PyErr_Occurred()) SWIG_fail;
9124 }
9125 {
9126 #if wxUSE_UNICODE
9127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9128 #else
9129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9130 #endif
9131 }
9132 {
9133 if (temp1)
9134 delete arg1;
9135 }
9136 return resultobj;
9137 fail:
9138 {
9139 if (temp1)
9140 delete arg1;
9141 }
9142 return NULL;
9143 }
9144
9145
9146 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9147 PyObject *resultobj;
9148 wxString *arg1 = 0 ;
9149 wxString result;
9150 bool temp1 = false ;
9151 PyObject * obj0 = 0 ;
9152 char *kwnames[] = {
9153 (char *) "url", NULL
9154 };
9155
9156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9157 {
9158 arg1 = wxString_in_helper(obj0);
9159 if (arg1 == NULL) SWIG_fail;
9160 temp1 = true;
9161 }
9162 {
9163 PyThreadState* __tstate = wxPyBeginAllowThreads();
9164 result = FileSystem_URLToFileName((wxString const &)*arg1);
9165
9166 wxPyEndAllowThreads(__tstate);
9167 if (PyErr_Occurred()) SWIG_fail;
9168 }
9169 {
9170 #if wxUSE_UNICODE
9171 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9172 #else
9173 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9174 #endif
9175 }
9176 {
9177 if (temp1)
9178 delete arg1;
9179 }
9180 return resultobj;
9181 fail:
9182 {
9183 if (temp1)
9184 delete arg1;
9185 }
9186 return NULL;
9187 }
9188
9189
9190 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9191 PyObject *obj;
9192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9193 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9194 Py_INCREF(obj);
9195 return Py_BuildValue((char *)"");
9196 }
9197 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9198 PyObject *resultobj;
9199 wxInternetFSHandler *result;
9200 char *kwnames[] = {
9201 NULL
9202 };
9203
9204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9205 {
9206 PyThreadState* __tstate = wxPyBeginAllowThreads();
9207 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9208
9209 wxPyEndAllowThreads(__tstate);
9210 if (PyErr_Occurred()) SWIG_fail;
9211 }
9212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9213 return resultobj;
9214 fail:
9215 return NULL;
9216 }
9217
9218
9219 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9220 PyObject *resultobj;
9221 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9222 wxString *arg2 = 0 ;
9223 bool result;
9224 bool temp2 = false ;
9225 PyObject * obj0 = 0 ;
9226 PyObject * obj1 = 0 ;
9227 char *kwnames[] = {
9228 (char *) "self",(char *) "location", NULL
9229 };
9230
9231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9233 if (SWIG_arg_fail(1)) SWIG_fail;
9234 {
9235 arg2 = wxString_in_helper(obj1);
9236 if (arg2 == NULL) SWIG_fail;
9237 temp2 = true;
9238 }
9239 {
9240 PyThreadState* __tstate = wxPyBeginAllowThreads();
9241 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9242
9243 wxPyEndAllowThreads(__tstate);
9244 if (PyErr_Occurred()) SWIG_fail;
9245 }
9246 {
9247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9248 }
9249 {
9250 if (temp2)
9251 delete arg2;
9252 }
9253 return resultobj;
9254 fail:
9255 {
9256 if (temp2)
9257 delete arg2;
9258 }
9259 return NULL;
9260 }
9261
9262
9263 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9264 PyObject *resultobj;
9265 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9266 wxFileSystem *arg2 = 0 ;
9267 wxString *arg3 = 0 ;
9268 wxFSFile *result;
9269 bool temp3 = false ;
9270 PyObject * obj0 = 0 ;
9271 PyObject * obj1 = 0 ;
9272 PyObject * obj2 = 0 ;
9273 char *kwnames[] = {
9274 (char *) "self",(char *) "fs",(char *) "location", NULL
9275 };
9276
9277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9279 if (SWIG_arg_fail(1)) SWIG_fail;
9280 {
9281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9282 if (SWIG_arg_fail(2)) SWIG_fail;
9283 if (arg2 == NULL) {
9284 SWIG_null_ref("wxFileSystem");
9285 }
9286 if (SWIG_arg_fail(2)) SWIG_fail;
9287 }
9288 {
9289 arg3 = wxString_in_helper(obj2);
9290 if (arg3 == NULL) SWIG_fail;
9291 temp3 = true;
9292 }
9293 {
9294 PyThreadState* __tstate = wxPyBeginAllowThreads();
9295 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9296
9297 wxPyEndAllowThreads(__tstate);
9298 if (PyErr_Occurred()) SWIG_fail;
9299 }
9300 {
9301 resultobj = wxPyMake_wxObject(result, 1);
9302 }
9303 {
9304 if (temp3)
9305 delete arg3;
9306 }
9307 return resultobj;
9308 fail:
9309 {
9310 if (temp3)
9311 delete arg3;
9312 }
9313 return NULL;
9314 }
9315
9316
9317 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9318 PyObject *obj;
9319 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9320 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9321 Py_INCREF(obj);
9322 return Py_BuildValue((char *)"");
9323 }
9324 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9325 PyObject *resultobj;
9326 wxZipFSHandler *result;
9327 char *kwnames[] = {
9328 NULL
9329 };
9330
9331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9332 {
9333 PyThreadState* __tstate = wxPyBeginAllowThreads();
9334 result = (wxZipFSHandler *)new wxZipFSHandler();
9335
9336 wxPyEndAllowThreads(__tstate);
9337 if (PyErr_Occurred()) SWIG_fail;
9338 }
9339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9340 return resultobj;
9341 fail:
9342 return NULL;
9343 }
9344
9345
9346 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9347 PyObject *resultobj;
9348 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9349 wxString *arg2 = 0 ;
9350 bool result;
9351 bool temp2 = false ;
9352 PyObject * obj0 = 0 ;
9353 PyObject * obj1 = 0 ;
9354 char *kwnames[] = {
9355 (char *) "self",(char *) "location", NULL
9356 };
9357
9358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9360 if (SWIG_arg_fail(1)) SWIG_fail;
9361 {
9362 arg2 = wxString_in_helper(obj1);
9363 if (arg2 == NULL) SWIG_fail;
9364 temp2 = true;
9365 }
9366 {
9367 PyThreadState* __tstate = wxPyBeginAllowThreads();
9368 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9369
9370 wxPyEndAllowThreads(__tstate);
9371 if (PyErr_Occurred()) SWIG_fail;
9372 }
9373 {
9374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9375 }
9376 {
9377 if (temp2)
9378 delete arg2;
9379 }
9380 return resultobj;
9381 fail:
9382 {
9383 if (temp2)
9384 delete arg2;
9385 }
9386 return NULL;
9387 }
9388
9389
9390 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9391 PyObject *resultobj;
9392 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9393 wxFileSystem *arg2 = 0 ;
9394 wxString *arg3 = 0 ;
9395 wxFSFile *result;
9396 bool temp3 = false ;
9397 PyObject * obj0 = 0 ;
9398 PyObject * obj1 = 0 ;
9399 PyObject * obj2 = 0 ;
9400 char *kwnames[] = {
9401 (char *) "self",(char *) "fs",(char *) "location", NULL
9402 };
9403
9404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9406 if (SWIG_arg_fail(1)) SWIG_fail;
9407 {
9408 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9409 if (SWIG_arg_fail(2)) SWIG_fail;
9410 if (arg2 == NULL) {
9411 SWIG_null_ref("wxFileSystem");
9412 }
9413 if (SWIG_arg_fail(2)) SWIG_fail;
9414 }
9415 {
9416 arg3 = wxString_in_helper(obj2);
9417 if (arg3 == NULL) SWIG_fail;
9418 temp3 = true;
9419 }
9420 {
9421 PyThreadState* __tstate = wxPyBeginAllowThreads();
9422 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9423
9424 wxPyEndAllowThreads(__tstate);
9425 if (PyErr_Occurred()) SWIG_fail;
9426 }
9427 {
9428 resultobj = wxPyMake_wxObject(result, 1);
9429 }
9430 {
9431 if (temp3)
9432 delete arg3;
9433 }
9434 return resultobj;
9435 fail:
9436 {
9437 if (temp3)
9438 delete arg3;
9439 }
9440 return NULL;
9441 }
9442
9443
9444 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9445 PyObject *resultobj;
9446 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9447 wxString *arg2 = 0 ;
9448 int arg3 = (int) 0 ;
9449 wxString result;
9450 bool temp2 = false ;
9451 PyObject * obj0 = 0 ;
9452 PyObject * obj1 = 0 ;
9453 PyObject * obj2 = 0 ;
9454 char *kwnames[] = {
9455 (char *) "self",(char *) "spec",(char *) "flags", NULL
9456 };
9457
9458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9460 if (SWIG_arg_fail(1)) SWIG_fail;
9461 {
9462 arg2 = wxString_in_helper(obj1);
9463 if (arg2 == NULL) SWIG_fail;
9464 temp2 = true;
9465 }
9466 if (obj2) {
9467 {
9468 arg3 = (int)(SWIG_As_int(obj2));
9469 if (SWIG_arg_fail(3)) SWIG_fail;
9470 }
9471 }
9472 {
9473 PyThreadState* __tstate = wxPyBeginAllowThreads();
9474 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9475
9476 wxPyEndAllowThreads(__tstate);
9477 if (PyErr_Occurred()) SWIG_fail;
9478 }
9479 {
9480 #if wxUSE_UNICODE
9481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9482 #else
9483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9484 #endif
9485 }
9486 {
9487 if (temp2)
9488 delete arg2;
9489 }
9490 return resultobj;
9491 fail:
9492 {
9493 if (temp2)
9494 delete arg2;
9495 }
9496 return NULL;
9497 }
9498
9499
9500 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9501 PyObject *resultobj;
9502 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9503 wxString result;
9504 PyObject * obj0 = 0 ;
9505 char *kwnames[] = {
9506 (char *) "self", NULL
9507 };
9508
9509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9511 if (SWIG_arg_fail(1)) SWIG_fail;
9512 {
9513 PyThreadState* __tstate = wxPyBeginAllowThreads();
9514 result = (arg1)->FindNext();
9515
9516 wxPyEndAllowThreads(__tstate);
9517 if (PyErr_Occurred()) SWIG_fail;
9518 }
9519 {
9520 #if wxUSE_UNICODE
9521 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9522 #else
9523 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9524 #endif
9525 }
9526 return resultobj;
9527 fail:
9528 return NULL;
9529 }
9530
9531
9532 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9533 PyObject *obj;
9534 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9535 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9536 Py_INCREF(obj);
9537 return Py_BuildValue((char *)"");
9538 }
9539 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9540 PyObject *resultobj;
9541 wxString *arg1 = 0 ;
9542 wxImage *arg2 = 0 ;
9543 long arg3 ;
9544 bool temp1 = false ;
9545 PyObject * obj0 = 0 ;
9546 PyObject * obj1 = 0 ;
9547 PyObject * obj2 = 0 ;
9548 char *kwnames[] = {
9549 (char *) "filename",(char *) "image",(char *) "type", NULL
9550 };
9551
9552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9553 {
9554 arg1 = wxString_in_helper(obj0);
9555 if (arg1 == NULL) SWIG_fail;
9556 temp1 = true;
9557 }
9558 {
9559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9560 if (SWIG_arg_fail(2)) SWIG_fail;
9561 if (arg2 == NULL) {
9562 SWIG_null_ref("wxImage");
9563 }
9564 if (SWIG_arg_fail(2)) SWIG_fail;
9565 }
9566 {
9567 arg3 = (long)(SWIG_As_long(obj2));
9568 if (SWIG_arg_fail(3)) SWIG_fail;
9569 }
9570 {
9571 PyThreadState* __tstate = wxPyBeginAllowThreads();
9572 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9573
9574 wxPyEndAllowThreads(__tstate);
9575 if (PyErr_Occurred()) SWIG_fail;
9576 }
9577 Py_INCREF(Py_None); resultobj = Py_None;
9578 {
9579 if (temp1)
9580 delete arg1;
9581 }
9582 return resultobj;
9583 fail:
9584 {
9585 if (temp1)
9586 delete arg1;
9587 }
9588 return NULL;
9589 }
9590
9591
9592 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9593 PyObject *resultobj;
9594 wxString *arg1 = 0 ;
9595 wxBitmap *arg2 = 0 ;
9596 long arg3 ;
9597 bool temp1 = false ;
9598 PyObject * obj0 = 0 ;
9599 PyObject * obj1 = 0 ;
9600 PyObject * obj2 = 0 ;
9601 char *kwnames[] = {
9602 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9603 };
9604
9605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9606 {
9607 arg1 = wxString_in_helper(obj0);
9608 if (arg1 == NULL) SWIG_fail;
9609 temp1 = true;
9610 }
9611 {
9612 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9613 if (SWIG_arg_fail(2)) SWIG_fail;
9614 if (arg2 == NULL) {
9615 SWIG_null_ref("wxBitmap");
9616 }
9617 if (SWIG_arg_fail(2)) SWIG_fail;
9618 }
9619 {
9620 arg3 = (long)(SWIG_As_long(obj2));
9621 if (SWIG_arg_fail(3)) SWIG_fail;
9622 }
9623 {
9624 PyThreadState* __tstate = wxPyBeginAllowThreads();
9625 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9626
9627 wxPyEndAllowThreads(__tstate);
9628 if (PyErr_Occurred()) SWIG_fail;
9629 }
9630 Py_INCREF(Py_None); resultobj = Py_None;
9631 {
9632 if (temp1)
9633 delete arg1;
9634 }
9635 return resultobj;
9636 fail:
9637 {
9638 if (temp1)
9639 delete arg1;
9640 }
9641 return NULL;
9642 }
9643
9644
9645 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj;
9647 wxString *arg1 = 0 ;
9648 PyObject *arg2 = (PyObject *) 0 ;
9649 bool temp1 = false ;
9650 PyObject * obj0 = 0 ;
9651 PyObject * obj1 = 0 ;
9652 char *kwnames[] = {
9653 (char *) "filename",(char *) "data", NULL
9654 };
9655
9656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9657 {
9658 arg1 = wxString_in_helper(obj0);
9659 if (arg1 == NULL) SWIG_fail;
9660 temp1 = true;
9661 }
9662 arg2 = obj1;
9663 {
9664 PyThreadState* __tstate = wxPyBeginAllowThreads();
9665 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9666
9667 wxPyEndAllowThreads(__tstate);
9668 if (PyErr_Occurred()) SWIG_fail;
9669 }
9670 Py_INCREF(Py_None); resultobj = Py_None;
9671 {
9672 if (temp1)
9673 delete arg1;
9674 }
9675 return resultobj;
9676 fail:
9677 {
9678 if (temp1)
9679 delete arg1;
9680 }
9681 return NULL;
9682 }
9683
9684
9685 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9686 PyObject *resultobj;
9687 wxMemoryFSHandler *result;
9688 char *kwnames[] = {
9689 NULL
9690 };
9691
9692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9693 {
9694 PyThreadState* __tstate = wxPyBeginAllowThreads();
9695 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9696
9697 wxPyEndAllowThreads(__tstate);
9698 if (PyErr_Occurred()) SWIG_fail;
9699 }
9700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9701 return resultobj;
9702 fail:
9703 return NULL;
9704 }
9705
9706
9707 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9708 PyObject *resultobj;
9709 wxString *arg1 = 0 ;
9710 bool temp1 = false ;
9711 PyObject * obj0 = 0 ;
9712 char *kwnames[] = {
9713 (char *) "filename", NULL
9714 };
9715
9716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9717 {
9718 arg1 = wxString_in_helper(obj0);
9719 if (arg1 == NULL) SWIG_fail;
9720 temp1 = true;
9721 }
9722 {
9723 PyThreadState* __tstate = wxPyBeginAllowThreads();
9724 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9725
9726 wxPyEndAllowThreads(__tstate);
9727 if (PyErr_Occurred()) SWIG_fail;
9728 }
9729 Py_INCREF(Py_None); resultobj = Py_None;
9730 {
9731 if (temp1)
9732 delete arg1;
9733 }
9734 return resultobj;
9735 fail:
9736 {
9737 if (temp1)
9738 delete arg1;
9739 }
9740 return NULL;
9741 }
9742
9743
9744 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9745 PyObject *resultobj;
9746 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9747 wxString *arg2 = 0 ;
9748 bool result;
9749 bool temp2 = false ;
9750 PyObject * obj0 = 0 ;
9751 PyObject * obj1 = 0 ;
9752 char *kwnames[] = {
9753 (char *) "self",(char *) "location", NULL
9754 };
9755
9756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9758 if (SWIG_arg_fail(1)) SWIG_fail;
9759 {
9760 arg2 = wxString_in_helper(obj1);
9761 if (arg2 == NULL) SWIG_fail;
9762 temp2 = true;
9763 }
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9767
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 {
9772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9773 }
9774 {
9775 if (temp2)
9776 delete arg2;
9777 }
9778 return resultobj;
9779 fail:
9780 {
9781 if (temp2)
9782 delete arg2;
9783 }
9784 return NULL;
9785 }
9786
9787
9788 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9789 PyObject *resultobj;
9790 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9791 wxFileSystem *arg2 = 0 ;
9792 wxString *arg3 = 0 ;
9793 wxFSFile *result;
9794 bool temp3 = false ;
9795 PyObject * obj0 = 0 ;
9796 PyObject * obj1 = 0 ;
9797 PyObject * obj2 = 0 ;
9798 char *kwnames[] = {
9799 (char *) "self",(char *) "fs",(char *) "location", NULL
9800 };
9801
9802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9804 if (SWIG_arg_fail(1)) SWIG_fail;
9805 {
9806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9807 if (SWIG_arg_fail(2)) SWIG_fail;
9808 if (arg2 == NULL) {
9809 SWIG_null_ref("wxFileSystem");
9810 }
9811 if (SWIG_arg_fail(2)) SWIG_fail;
9812 }
9813 {
9814 arg3 = wxString_in_helper(obj2);
9815 if (arg3 == NULL) SWIG_fail;
9816 temp3 = true;
9817 }
9818 {
9819 PyThreadState* __tstate = wxPyBeginAllowThreads();
9820 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9821
9822 wxPyEndAllowThreads(__tstate);
9823 if (PyErr_Occurred()) SWIG_fail;
9824 }
9825 {
9826 resultobj = wxPyMake_wxObject(result, 1);
9827 }
9828 {
9829 if (temp3)
9830 delete arg3;
9831 }
9832 return resultobj;
9833 fail:
9834 {
9835 if (temp3)
9836 delete arg3;
9837 }
9838 return NULL;
9839 }
9840
9841
9842 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9843 PyObject *resultobj;
9844 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9845 wxString *arg2 = 0 ;
9846 int arg3 = (int) 0 ;
9847 wxString result;
9848 bool temp2 = false ;
9849 PyObject * obj0 = 0 ;
9850 PyObject * obj1 = 0 ;
9851 PyObject * obj2 = 0 ;
9852 char *kwnames[] = {
9853 (char *) "self",(char *) "spec",(char *) "flags", NULL
9854 };
9855
9856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9858 if (SWIG_arg_fail(1)) SWIG_fail;
9859 {
9860 arg2 = wxString_in_helper(obj1);
9861 if (arg2 == NULL) SWIG_fail;
9862 temp2 = true;
9863 }
9864 if (obj2) {
9865 {
9866 arg3 = (int)(SWIG_As_int(obj2));
9867 if (SWIG_arg_fail(3)) SWIG_fail;
9868 }
9869 }
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9873
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 {
9878 #if wxUSE_UNICODE
9879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9880 #else
9881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9882 #endif
9883 }
9884 {
9885 if (temp2)
9886 delete arg2;
9887 }
9888 return resultobj;
9889 fail:
9890 {
9891 if (temp2)
9892 delete arg2;
9893 }
9894 return NULL;
9895 }
9896
9897
9898 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9899 PyObject *resultobj;
9900 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9901 wxString result;
9902 PyObject * obj0 = 0 ;
9903 char *kwnames[] = {
9904 (char *) "self", NULL
9905 };
9906
9907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9909 if (SWIG_arg_fail(1)) SWIG_fail;
9910 {
9911 PyThreadState* __tstate = wxPyBeginAllowThreads();
9912 result = (arg1)->FindNext();
9913
9914 wxPyEndAllowThreads(__tstate);
9915 if (PyErr_Occurred()) SWIG_fail;
9916 }
9917 {
9918 #if wxUSE_UNICODE
9919 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9920 #else
9921 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9922 #endif
9923 }
9924 return resultobj;
9925 fail:
9926 return NULL;
9927 }
9928
9929
9930 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9931 PyObject *obj;
9932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9933 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9934 Py_INCREF(obj);
9935 return Py_BuildValue((char *)"");
9936 }
9937 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj;
9939 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9940 wxString result;
9941 PyObject * obj0 = 0 ;
9942 char *kwnames[] = {
9943 (char *) "self", NULL
9944 };
9945
9946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9948 if (SWIG_arg_fail(1)) SWIG_fail;
9949 {
9950 PyThreadState* __tstate = wxPyBeginAllowThreads();
9951 result = (arg1)->GetName();
9952
9953 wxPyEndAllowThreads(__tstate);
9954 if (PyErr_Occurred()) SWIG_fail;
9955 }
9956 {
9957 #if wxUSE_UNICODE
9958 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9959 #else
9960 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9961 #endif
9962 }
9963 return resultobj;
9964 fail:
9965 return NULL;
9966 }
9967
9968
9969 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9970 PyObject *resultobj;
9971 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9972 wxString result;
9973 PyObject * obj0 = 0 ;
9974 char *kwnames[] = {
9975 (char *) "self", NULL
9976 };
9977
9978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9980 if (SWIG_arg_fail(1)) SWIG_fail;
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 result = (arg1)->GetExtension();
9984
9985 wxPyEndAllowThreads(__tstate);
9986 if (PyErr_Occurred()) SWIG_fail;
9987 }
9988 {
9989 #if wxUSE_UNICODE
9990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9991 #else
9992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9993 #endif
9994 }
9995 return resultobj;
9996 fail:
9997 return NULL;
9998 }
9999
10000
10001 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
10002 PyObject *resultobj;
10003 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10004 long result;
10005 PyObject * obj0 = 0 ;
10006 char *kwnames[] = {
10007 (char *) "self", NULL
10008 };
10009
10010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
10011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10012 if (SWIG_arg_fail(1)) SWIG_fail;
10013 {
10014 PyThreadState* __tstate = wxPyBeginAllowThreads();
10015 result = (long)(arg1)->GetType();
10016
10017 wxPyEndAllowThreads(__tstate);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 {
10021 resultobj = SWIG_From_long((long)(result));
10022 }
10023 return resultobj;
10024 fail:
10025 return NULL;
10026 }
10027
10028
10029 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10030 PyObject *resultobj;
10031 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10032 wxString result;
10033 PyObject * obj0 = 0 ;
10034 char *kwnames[] = {
10035 (char *) "self", NULL
10036 };
10037
10038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10040 if (SWIG_arg_fail(1)) SWIG_fail;
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 result = (arg1)->GetMimeType();
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 {
10049 #if wxUSE_UNICODE
10050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10051 #else
10052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10053 #endif
10054 }
10055 return resultobj;
10056 fail:
10057 return NULL;
10058 }
10059
10060
10061 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10062 PyObject *resultobj;
10063 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10064 wxString *arg2 = 0 ;
10065 bool result;
10066 bool temp2 = false ;
10067 PyObject * obj0 = 0 ;
10068 PyObject * obj1 = 0 ;
10069 char *kwnames[] = {
10070 (char *) "self",(char *) "name", NULL
10071 };
10072
10073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10075 if (SWIG_arg_fail(1)) SWIG_fail;
10076 {
10077 arg2 = wxString_in_helper(obj1);
10078 if (arg2 == NULL) SWIG_fail;
10079 temp2 = true;
10080 }
10081 {
10082 PyThreadState* __tstate = wxPyBeginAllowThreads();
10083 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10084
10085 wxPyEndAllowThreads(__tstate);
10086 if (PyErr_Occurred()) SWIG_fail;
10087 }
10088 {
10089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10090 }
10091 {
10092 if (temp2)
10093 delete arg2;
10094 }
10095 return resultobj;
10096 fail:
10097 {
10098 if (temp2)
10099 delete arg2;
10100 }
10101 return NULL;
10102 }
10103
10104
10105 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj;
10107 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10108 wxString *arg2 = 0 ;
10109 bool temp2 = false ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char *kwnames[] = {
10113 (char *) "self",(char *) "name", NULL
10114 };
10115
10116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10118 if (SWIG_arg_fail(1)) SWIG_fail;
10119 {
10120 arg2 = wxString_in_helper(obj1);
10121 if (arg2 == NULL) SWIG_fail;
10122 temp2 = true;
10123 }
10124 {
10125 PyThreadState* __tstate = wxPyBeginAllowThreads();
10126 (arg1)->SetName((wxString const &)*arg2);
10127
10128 wxPyEndAllowThreads(__tstate);
10129 if (PyErr_Occurred()) SWIG_fail;
10130 }
10131 Py_INCREF(Py_None); resultobj = Py_None;
10132 {
10133 if (temp2)
10134 delete arg2;
10135 }
10136 return resultobj;
10137 fail:
10138 {
10139 if (temp2)
10140 delete arg2;
10141 }
10142 return NULL;
10143 }
10144
10145
10146 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10147 PyObject *resultobj;
10148 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10149 wxString *arg2 = 0 ;
10150 bool temp2 = false ;
10151 PyObject * obj0 = 0 ;
10152 PyObject * obj1 = 0 ;
10153 char *kwnames[] = {
10154 (char *) "self",(char *) "extension", NULL
10155 };
10156
10157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10159 if (SWIG_arg_fail(1)) SWIG_fail;
10160 {
10161 arg2 = wxString_in_helper(obj1);
10162 if (arg2 == NULL) SWIG_fail;
10163 temp2 = true;
10164 }
10165 {
10166 PyThreadState* __tstate = wxPyBeginAllowThreads();
10167 (arg1)->SetExtension((wxString const &)*arg2);
10168
10169 wxPyEndAllowThreads(__tstate);
10170 if (PyErr_Occurred()) SWIG_fail;
10171 }
10172 Py_INCREF(Py_None); resultobj = Py_None;
10173 {
10174 if (temp2)
10175 delete arg2;
10176 }
10177 return resultobj;
10178 fail:
10179 {
10180 if (temp2)
10181 delete arg2;
10182 }
10183 return NULL;
10184 }
10185
10186
10187 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10188 PyObject *resultobj;
10189 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10190 long arg2 ;
10191 PyObject * obj0 = 0 ;
10192 PyObject * obj1 = 0 ;
10193 char *kwnames[] = {
10194 (char *) "self",(char *) "type", NULL
10195 };
10196
10197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10199 if (SWIG_arg_fail(1)) SWIG_fail;
10200 {
10201 arg2 = (long)(SWIG_As_long(obj1));
10202 if (SWIG_arg_fail(2)) SWIG_fail;
10203 }
10204 {
10205 PyThreadState* __tstate = wxPyBeginAllowThreads();
10206 (arg1)->SetType(arg2);
10207
10208 wxPyEndAllowThreads(__tstate);
10209 if (PyErr_Occurred()) SWIG_fail;
10210 }
10211 Py_INCREF(Py_None); resultobj = Py_None;
10212 return resultobj;
10213 fail:
10214 return NULL;
10215 }
10216
10217
10218 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10219 PyObject *resultobj;
10220 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10221 wxString *arg2 = 0 ;
10222 bool temp2 = false ;
10223 PyObject * obj0 = 0 ;
10224 PyObject * obj1 = 0 ;
10225 char *kwnames[] = {
10226 (char *) "self",(char *) "mimetype", NULL
10227 };
10228
10229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10231 if (SWIG_arg_fail(1)) SWIG_fail;
10232 {
10233 arg2 = wxString_in_helper(obj1);
10234 if (arg2 == NULL) SWIG_fail;
10235 temp2 = true;
10236 }
10237 {
10238 PyThreadState* __tstate = wxPyBeginAllowThreads();
10239 (arg1)->SetMimeType((wxString const &)*arg2);
10240
10241 wxPyEndAllowThreads(__tstate);
10242 if (PyErr_Occurred()) SWIG_fail;
10243 }
10244 Py_INCREF(Py_None); resultobj = Py_None;
10245 {
10246 if (temp2)
10247 delete arg2;
10248 }
10249 return resultobj;
10250 fail:
10251 {
10252 if (temp2)
10253 delete arg2;
10254 }
10255 return NULL;
10256 }
10257
10258
10259 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10260 PyObject *obj;
10261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10262 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10263 Py_INCREF(obj);
10264 return Py_BuildValue((char *)"");
10265 }
10266 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10267 PyObject *resultobj;
10268 wxPyImageHandler *result;
10269 char *kwnames[] = {
10270 NULL
10271 };
10272
10273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (wxPyImageHandler *)new wxPyImageHandler();
10277
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10282 return resultobj;
10283 fail:
10284 return NULL;
10285 }
10286
10287
10288 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10289 PyObject *resultobj;
10290 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10291 PyObject *arg2 = (PyObject *) 0 ;
10292 PyObject * obj0 = 0 ;
10293 PyObject * obj1 = 0 ;
10294 char *kwnames[] = {
10295 (char *) "self",(char *) "self", NULL
10296 };
10297
10298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10300 if (SWIG_arg_fail(1)) SWIG_fail;
10301 arg2 = obj1;
10302 {
10303 PyThreadState* __tstate = wxPyBeginAllowThreads();
10304 (arg1)->_SetSelf(arg2);
10305
10306 wxPyEndAllowThreads(__tstate);
10307 if (PyErr_Occurred()) SWIG_fail;
10308 }
10309 Py_INCREF(Py_None); resultobj = Py_None;
10310 return resultobj;
10311 fail:
10312 return NULL;
10313 }
10314
10315
10316 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10317 PyObject *obj;
10318 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10319 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10320 Py_INCREF(obj);
10321 return Py_BuildValue((char *)"");
10322 }
10323 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10324 PyObject *resultobj;
10325 wxImageHistogram *result;
10326 char *kwnames[] = {
10327 NULL
10328 };
10329
10330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10331 {
10332 PyThreadState* __tstate = wxPyBeginAllowThreads();
10333 result = (wxImageHistogram *)new wxImageHistogram();
10334
10335 wxPyEndAllowThreads(__tstate);
10336 if (PyErr_Occurred()) SWIG_fail;
10337 }
10338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10339 return resultobj;
10340 fail:
10341 return NULL;
10342 }
10343
10344
10345 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10346 PyObject *resultobj;
10347 byte arg1 ;
10348 byte arg2 ;
10349 byte arg3 ;
10350 unsigned long result;
10351 PyObject * obj0 = 0 ;
10352 PyObject * obj1 = 0 ;
10353 PyObject * obj2 = 0 ;
10354 char *kwnames[] = {
10355 (char *) "r",(char *) "g",(char *) "b", NULL
10356 };
10357
10358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10359 {
10360 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10361 if (SWIG_arg_fail(1)) SWIG_fail;
10362 }
10363 {
10364 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10365 if (SWIG_arg_fail(2)) SWIG_fail;
10366 }
10367 {
10368 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10369 if (SWIG_arg_fail(3)) SWIG_fail;
10370 }
10371 {
10372 PyThreadState* __tstate = wxPyBeginAllowThreads();
10373 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10374
10375 wxPyEndAllowThreads(__tstate);
10376 if (PyErr_Occurred()) SWIG_fail;
10377 }
10378 {
10379 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10380 }
10381 return resultobj;
10382 fail:
10383 return NULL;
10384 }
10385
10386
10387 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10388 PyObject *resultobj;
10389 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10390 byte *arg2 = (byte *) 0 ;
10391 byte *arg3 = (byte *) 0 ;
10392 byte *arg4 = (byte *) 0 ;
10393 byte arg5 = (byte) 1 ;
10394 byte arg6 = (byte) 0 ;
10395 byte arg7 = (byte) 0 ;
10396 bool result;
10397 byte temp2 ;
10398 int res2 = 0 ;
10399 byte temp3 ;
10400 int res3 = 0 ;
10401 byte temp4 ;
10402 int res4 = 0 ;
10403 PyObject * obj0 = 0 ;
10404 PyObject * obj1 = 0 ;
10405 PyObject * obj2 = 0 ;
10406 PyObject * obj3 = 0 ;
10407 char *kwnames[] = {
10408 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10409 };
10410
10411 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10412 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10413 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10416 if (SWIG_arg_fail(1)) SWIG_fail;
10417 if (obj1) {
10418 {
10419 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10420 if (SWIG_arg_fail(5)) SWIG_fail;
10421 }
10422 }
10423 if (obj2) {
10424 {
10425 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10426 if (SWIG_arg_fail(6)) SWIG_fail;
10427 }
10428 }
10429 if (obj3) {
10430 {
10431 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10432 if (SWIG_arg_fail(7)) SWIG_fail;
10433 }
10434 }
10435 {
10436 PyThreadState* __tstate = wxPyBeginAllowThreads();
10437 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10438
10439 wxPyEndAllowThreads(__tstate);
10440 if (PyErr_Occurred()) SWIG_fail;
10441 }
10442 {
10443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10444 }
10445 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10446 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10447 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10448 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10449 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10450 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10451 return resultobj;
10452 fail:
10453 return NULL;
10454 }
10455
10456
10457 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10458 PyObject *resultobj;
10459 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10460 unsigned long arg2 ;
10461 unsigned long result;
10462 PyObject * obj0 = 0 ;
10463 PyObject * obj1 = 0 ;
10464 char *kwnames[] = {
10465 (char *) "self",(char *) "key", NULL
10466 };
10467
10468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10470 if (SWIG_arg_fail(1)) SWIG_fail;
10471 {
10472 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10473 if (SWIG_arg_fail(2)) SWIG_fail;
10474 }
10475 {
10476 PyThreadState* __tstate = wxPyBeginAllowThreads();
10477 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10478
10479 wxPyEndAllowThreads(__tstate);
10480 if (PyErr_Occurred()) SWIG_fail;
10481 }
10482 {
10483 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10484 }
10485 return resultobj;
10486 fail:
10487 return NULL;
10488 }
10489
10490
10491 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10492 PyObject *resultobj;
10493 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10494 byte arg2 ;
10495 byte arg3 ;
10496 byte arg4 ;
10497 unsigned long result;
10498 PyObject * obj0 = 0 ;
10499 PyObject * obj1 = 0 ;
10500 PyObject * obj2 = 0 ;
10501 PyObject * obj3 = 0 ;
10502 char *kwnames[] = {
10503 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10504 };
10505
10506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10508 if (SWIG_arg_fail(1)) SWIG_fail;
10509 {
10510 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10511 if (SWIG_arg_fail(2)) SWIG_fail;
10512 }
10513 {
10514 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10515 if (SWIG_arg_fail(3)) SWIG_fail;
10516 }
10517 {
10518 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10519 if (SWIG_arg_fail(4)) SWIG_fail;
10520 }
10521 {
10522 PyThreadState* __tstate = wxPyBeginAllowThreads();
10523 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10524
10525 wxPyEndAllowThreads(__tstate);
10526 if (PyErr_Occurred()) SWIG_fail;
10527 }
10528 {
10529 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10530 }
10531 return resultobj;
10532 fail:
10533 return NULL;
10534 }
10535
10536
10537 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10538 PyObject *resultobj;
10539 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10540 wxColour *arg2 = 0 ;
10541 unsigned long result;
10542 wxColour temp2 ;
10543 PyObject * obj0 = 0 ;
10544 PyObject * obj1 = 0 ;
10545 char *kwnames[] = {
10546 (char *) "self",(char *) "colour", NULL
10547 };
10548
10549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10551 if (SWIG_arg_fail(1)) SWIG_fail;
10552 {
10553 arg2 = &temp2;
10554 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10555 }
10556 {
10557 PyThreadState* __tstate = wxPyBeginAllowThreads();
10558 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10559
10560 wxPyEndAllowThreads(__tstate);
10561 if (PyErr_Occurred()) SWIG_fail;
10562 }
10563 {
10564 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10565 }
10566 return resultobj;
10567 fail:
10568 return NULL;
10569 }
10570
10571
10572 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10573 PyObject *obj;
10574 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10575 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10576 Py_INCREF(obj);
10577 return Py_BuildValue((char *)"");
10578 }
10579 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10580 PyObject *resultobj;
10581 byte arg1 = (byte) 0 ;
10582 byte arg2 = (byte) 0 ;
10583 byte arg3 = (byte) 0 ;
10584 wxImage_RGBValue *result;
10585 PyObject * obj0 = 0 ;
10586 PyObject * obj1 = 0 ;
10587 PyObject * obj2 = 0 ;
10588 char *kwnames[] = {
10589 (char *) "r",(char *) "g",(char *) "b", NULL
10590 };
10591
10592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10593 if (obj0) {
10594 {
10595 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10596 if (SWIG_arg_fail(1)) SWIG_fail;
10597 }
10598 }
10599 if (obj1) {
10600 {
10601 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10602 if (SWIG_arg_fail(2)) SWIG_fail;
10603 }
10604 }
10605 if (obj2) {
10606 {
10607 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10608 if (SWIG_arg_fail(3)) SWIG_fail;
10609 }
10610 }
10611 {
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10614
10615 wxPyEndAllowThreads(__tstate);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10619 return resultobj;
10620 fail:
10621 return NULL;
10622 }
10623
10624
10625 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10626 PyObject *resultobj;
10627 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10628 byte arg2 ;
10629 PyObject * obj0 = 0 ;
10630 PyObject * obj1 = 0 ;
10631 char *kwnames[] = {
10632 (char *) "self",(char *) "red", NULL
10633 };
10634
10635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10637 if (SWIG_arg_fail(1)) SWIG_fail;
10638 {
10639 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10640 if (SWIG_arg_fail(2)) SWIG_fail;
10641 }
10642 if (arg1) (arg1)->red = arg2;
10643
10644 Py_INCREF(Py_None); resultobj = Py_None;
10645 return resultobj;
10646 fail:
10647 return NULL;
10648 }
10649
10650
10651 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10652 PyObject *resultobj;
10653 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10654 byte result;
10655 PyObject * obj0 = 0 ;
10656 char *kwnames[] = {
10657 (char *) "self", NULL
10658 };
10659
10660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10662 if (SWIG_arg_fail(1)) SWIG_fail;
10663 result = (byte) ((arg1)->red);
10664
10665 {
10666 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10667 }
10668 return resultobj;
10669 fail:
10670 return NULL;
10671 }
10672
10673
10674 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10675 PyObject *resultobj;
10676 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10677 byte arg2 ;
10678 PyObject * obj0 = 0 ;
10679 PyObject * obj1 = 0 ;
10680 char *kwnames[] = {
10681 (char *) "self",(char *) "green", NULL
10682 };
10683
10684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10686 if (SWIG_arg_fail(1)) SWIG_fail;
10687 {
10688 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10689 if (SWIG_arg_fail(2)) SWIG_fail;
10690 }
10691 if (arg1) (arg1)->green = arg2;
10692
10693 Py_INCREF(Py_None); resultobj = Py_None;
10694 return resultobj;
10695 fail:
10696 return NULL;
10697 }
10698
10699
10700 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10701 PyObject *resultobj;
10702 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10703 byte result;
10704 PyObject * obj0 = 0 ;
10705 char *kwnames[] = {
10706 (char *) "self", NULL
10707 };
10708
10709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10711 if (SWIG_arg_fail(1)) SWIG_fail;
10712 result = (byte) ((arg1)->green);
10713
10714 {
10715 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10716 }
10717 return resultobj;
10718 fail:
10719 return NULL;
10720 }
10721
10722
10723 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10724 PyObject *resultobj;
10725 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10726 byte arg2 ;
10727 PyObject * obj0 = 0 ;
10728 PyObject * obj1 = 0 ;
10729 char *kwnames[] = {
10730 (char *) "self",(char *) "blue", NULL
10731 };
10732
10733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10735 if (SWIG_arg_fail(1)) SWIG_fail;
10736 {
10737 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10738 if (SWIG_arg_fail(2)) SWIG_fail;
10739 }
10740 if (arg1) (arg1)->blue = arg2;
10741
10742 Py_INCREF(Py_None); resultobj = Py_None;
10743 return resultobj;
10744 fail:
10745 return NULL;
10746 }
10747
10748
10749 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10750 PyObject *resultobj;
10751 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10752 byte result;
10753 PyObject * obj0 = 0 ;
10754 char *kwnames[] = {
10755 (char *) "self", NULL
10756 };
10757
10758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10760 if (SWIG_arg_fail(1)) SWIG_fail;
10761 result = (byte) ((arg1)->blue);
10762
10763 {
10764 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10765 }
10766 return resultobj;
10767 fail:
10768 return NULL;
10769 }
10770
10771
10772 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10773 PyObject *obj;
10774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10775 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10776 Py_INCREF(obj);
10777 return Py_BuildValue((char *)"");
10778 }
10779 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10780 PyObject *resultobj;
10781 double arg1 = (double) 0.0 ;
10782 double arg2 = (double) 0.0 ;
10783 double arg3 = (double) 0.0 ;
10784 wxImage_HSVValue *result;
10785 PyObject * obj0 = 0 ;
10786 PyObject * obj1 = 0 ;
10787 PyObject * obj2 = 0 ;
10788 char *kwnames[] = {
10789 (char *) "h",(char *) "s",(char *) "v", NULL
10790 };
10791
10792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10793 if (obj0) {
10794 {
10795 arg1 = (double)(SWIG_As_double(obj0));
10796 if (SWIG_arg_fail(1)) SWIG_fail;
10797 }
10798 }
10799 if (obj1) {
10800 {
10801 arg2 = (double)(SWIG_As_double(obj1));
10802 if (SWIG_arg_fail(2)) SWIG_fail;
10803 }
10804 }
10805 if (obj2) {
10806 {
10807 arg3 = (double)(SWIG_As_double(obj2));
10808 if (SWIG_arg_fail(3)) SWIG_fail;
10809 }
10810 }
10811 {
10812 PyThreadState* __tstate = wxPyBeginAllowThreads();
10813 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10814
10815 wxPyEndAllowThreads(__tstate);
10816 if (PyErr_Occurred()) SWIG_fail;
10817 }
10818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10819 return resultobj;
10820 fail:
10821 return NULL;
10822 }
10823
10824
10825 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10826 PyObject *resultobj;
10827 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10828 double arg2 ;
10829 PyObject * obj0 = 0 ;
10830 PyObject * obj1 = 0 ;
10831 char *kwnames[] = {
10832 (char *) "self",(char *) "hue", NULL
10833 };
10834
10835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10837 if (SWIG_arg_fail(1)) SWIG_fail;
10838 {
10839 arg2 = (double)(SWIG_As_double(obj1));
10840 if (SWIG_arg_fail(2)) SWIG_fail;
10841 }
10842 if (arg1) (arg1)->hue = arg2;
10843
10844 Py_INCREF(Py_None); resultobj = Py_None;
10845 return resultobj;
10846 fail:
10847 return NULL;
10848 }
10849
10850
10851 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10852 PyObject *resultobj;
10853 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10854 double result;
10855 PyObject * obj0 = 0 ;
10856 char *kwnames[] = {
10857 (char *) "self", NULL
10858 };
10859
10860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
10861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10862 if (SWIG_arg_fail(1)) SWIG_fail;
10863 result = (double) ((arg1)->hue);
10864
10865 {
10866 resultobj = SWIG_From_double((double)(result));
10867 }
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj;
10876 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10877 double arg2 ;
10878 PyObject * obj0 = 0 ;
10879 PyObject * obj1 = 0 ;
10880 char *kwnames[] = {
10881 (char *) "self",(char *) "saturation", NULL
10882 };
10883
10884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
10885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10886 if (SWIG_arg_fail(1)) SWIG_fail;
10887 {
10888 arg2 = (double)(SWIG_As_double(obj1));
10889 if (SWIG_arg_fail(2)) SWIG_fail;
10890 }
10891 if (arg1) (arg1)->saturation = arg2;
10892
10893 Py_INCREF(Py_None); resultobj = Py_None;
10894 return resultobj;
10895 fail:
10896 return NULL;
10897 }
10898
10899
10900 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
10901 PyObject *resultobj;
10902 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10903 double result;
10904 PyObject * obj0 = 0 ;
10905 char *kwnames[] = {
10906 (char *) "self", NULL
10907 };
10908
10909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
10910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10911 if (SWIG_arg_fail(1)) SWIG_fail;
10912 result = (double) ((arg1)->saturation);
10913
10914 {
10915 resultobj = SWIG_From_double((double)(result));
10916 }
10917 return resultobj;
10918 fail:
10919 return NULL;
10920 }
10921
10922
10923 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
10924 PyObject *resultobj;
10925 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10926 double arg2 ;
10927 PyObject * obj0 = 0 ;
10928 PyObject * obj1 = 0 ;
10929 char *kwnames[] = {
10930 (char *) "self",(char *) "value", NULL
10931 };
10932
10933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
10934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10935 if (SWIG_arg_fail(1)) SWIG_fail;
10936 {
10937 arg2 = (double)(SWIG_As_double(obj1));
10938 if (SWIG_arg_fail(2)) SWIG_fail;
10939 }
10940 if (arg1) (arg1)->value = arg2;
10941
10942 Py_INCREF(Py_None); resultobj = Py_None;
10943 return resultobj;
10944 fail:
10945 return NULL;
10946 }
10947
10948
10949 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
10950 PyObject *resultobj;
10951 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10952 double result;
10953 PyObject * obj0 = 0 ;
10954 char *kwnames[] = {
10955 (char *) "self", NULL
10956 };
10957
10958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
10959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10960 if (SWIG_arg_fail(1)) SWIG_fail;
10961 result = (double) ((arg1)->value);
10962
10963 {
10964 resultobj = SWIG_From_double((double)(result));
10965 }
10966 return resultobj;
10967 fail:
10968 return NULL;
10969 }
10970
10971
10972 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
10973 PyObject *obj;
10974 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10975 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
10976 Py_INCREF(obj);
10977 return Py_BuildValue((char *)"");
10978 }
10979 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10980 PyObject *resultobj;
10981 wxString *arg1 = 0 ;
10982 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10983 int arg3 = (int) -1 ;
10984 wxImage *result;
10985 bool temp1 = false ;
10986 PyObject * obj0 = 0 ;
10987 PyObject * obj1 = 0 ;
10988 PyObject * obj2 = 0 ;
10989 char *kwnames[] = {
10990 (char *) "name",(char *) "type",(char *) "index", NULL
10991 };
10992
10993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10994 {
10995 arg1 = wxString_in_helper(obj0);
10996 if (arg1 == NULL) SWIG_fail;
10997 temp1 = true;
10998 }
10999 if (obj1) {
11000 {
11001 arg2 = (long)(SWIG_As_long(obj1));
11002 if (SWIG_arg_fail(2)) SWIG_fail;
11003 }
11004 }
11005 if (obj2) {
11006 {
11007 arg3 = (int)(SWIG_As_int(obj2));
11008 if (SWIG_arg_fail(3)) SWIG_fail;
11009 }
11010 }
11011 {
11012 PyThreadState* __tstate = wxPyBeginAllowThreads();
11013 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
11014
11015 wxPyEndAllowThreads(__tstate);
11016 if (PyErr_Occurred()) SWIG_fail;
11017 }
11018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11019 {
11020 if (temp1)
11021 delete arg1;
11022 }
11023 return resultobj;
11024 fail:
11025 {
11026 if (temp1)
11027 delete arg1;
11028 }
11029 return NULL;
11030 }
11031
11032
11033 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11034 PyObject *resultobj;
11035 wxImage *arg1 = (wxImage *) 0 ;
11036 PyObject * obj0 = 0 ;
11037 char *kwnames[] = {
11038 (char *) "self", NULL
11039 };
11040
11041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11043 if (SWIG_arg_fail(1)) SWIG_fail;
11044 {
11045 PyThreadState* __tstate = wxPyBeginAllowThreads();
11046 delete arg1;
11047
11048 wxPyEndAllowThreads(__tstate);
11049 if (PyErr_Occurred()) SWIG_fail;
11050 }
11051 Py_INCREF(Py_None); resultobj = Py_None;
11052 return resultobj;
11053 fail:
11054 return NULL;
11055 }
11056
11057
11058 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11059 PyObject *resultobj;
11060 wxString *arg1 = 0 ;
11061 wxString *arg2 = 0 ;
11062 int arg3 = (int) -1 ;
11063 wxImage *result;
11064 bool temp1 = false ;
11065 bool temp2 = false ;
11066 PyObject * obj0 = 0 ;
11067 PyObject * obj1 = 0 ;
11068 PyObject * obj2 = 0 ;
11069 char *kwnames[] = {
11070 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11071 };
11072
11073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11074 {
11075 arg1 = wxString_in_helper(obj0);
11076 if (arg1 == NULL) SWIG_fail;
11077 temp1 = true;
11078 }
11079 {
11080 arg2 = wxString_in_helper(obj1);
11081 if (arg2 == NULL) SWIG_fail;
11082 temp2 = true;
11083 }
11084 if (obj2) {
11085 {
11086 arg3 = (int)(SWIG_As_int(obj2));
11087 if (SWIG_arg_fail(3)) SWIG_fail;
11088 }
11089 }
11090 {
11091 PyThreadState* __tstate = wxPyBeginAllowThreads();
11092 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11093
11094 wxPyEndAllowThreads(__tstate);
11095 if (PyErr_Occurred()) SWIG_fail;
11096 }
11097 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11098 {
11099 if (temp1)
11100 delete arg1;
11101 }
11102 {
11103 if (temp2)
11104 delete arg2;
11105 }
11106 return resultobj;
11107 fail:
11108 {
11109 if (temp1)
11110 delete arg1;
11111 }
11112 {
11113 if (temp2)
11114 delete arg2;
11115 }
11116 return NULL;
11117 }
11118
11119
11120 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11121 PyObject *resultobj;
11122 wxInputStream *arg1 = 0 ;
11123 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11124 int arg3 = (int) -1 ;
11125 wxImage *result;
11126 wxPyInputStream *temp1 ;
11127 bool created1 ;
11128 PyObject * obj0 = 0 ;
11129 PyObject * obj1 = 0 ;
11130 PyObject * obj2 = 0 ;
11131 char *kwnames[] = {
11132 (char *) "stream",(char *) "type",(char *) "index", NULL
11133 };
11134
11135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11136 {
11137 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11138 arg1 = temp1->m_wxis;
11139 created1 = false;
11140 } else {
11141 PyErr_Clear(); // clear the failure of the wxPyConvert above
11142 arg1 = wxPyCBInputStream_create(obj0, false);
11143 if (arg1 == NULL) {
11144 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11145 SWIG_fail;
11146 }
11147 created1 = true;
11148 }
11149 }
11150 if (obj1) {
11151 {
11152 arg2 = (long)(SWIG_As_long(obj1));
11153 if (SWIG_arg_fail(2)) SWIG_fail;
11154 }
11155 }
11156 if (obj2) {
11157 {
11158 arg3 = (int)(SWIG_As_int(obj2));
11159 if (SWIG_arg_fail(3)) SWIG_fail;
11160 }
11161 }
11162 {
11163 PyThreadState* __tstate = wxPyBeginAllowThreads();
11164 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11165
11166 wxPyEndAllowThreads(__tstate);
11167 if (PyErr_Occurred()) SWIG_fail;
11168 }
11169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11170 {
11171 if (created1) delete arg1;
11172 }
11173 return resultobj;
11174 fail:
11175 {
11176 if (created1) delete arg1;
11177 }
11178 return NULL;
11179 }
11180
11181
11182 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11183 PyObject *resultobj;
11184 wxInputStream *arg1 = 0 ;
11185 wxString *arg2 = 0 ;
11186 int arg3 = (int) -1 ;
11187 wxImage *result;
11188 wxPyInputStream *temp1 ;
11189 bool created1 ;
11190 bool temp2 = false ;
11191 PyObject * obj0 = 0 ;
11192 PyObject * obj1 = 0 ;
11193 PyObject * obj2 = 0 ;
11194 char *kwnames[] = {
11195 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11196 };
11197
11198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11199 {
11200 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11201 arg1 = temp1->m_wxis;
11202 created1 = false;
11203 } else {
11204 PyErr_Clear(); // clear the failure of the wxPyConvert above
11205 arg1 = wxPyCBInputStream_create(obj0, false);
11206 if (arg1 == NULL) {
11207 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11208 SWIG_fail;
11209 }
11210 created1 = true;
11211 }
11212 }
11213 {
11214 arg2 = wxString_in_helper(obj1);
11215 if (arg2 == NULL) SWIG_fail;
11216 temp2 = true;
11217 }
11218 if (obj2) {
11219 {
11220 arg3 = (int)(SWIG_As_int(obj2));
11221 if (SWIG_arg_fail(3)) SWIG_fail;
11222 }
11223 }
11224 {
11225 PyThreadState* __tstate = wxPyBeginAllowThreads();
11226 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11227
11228 wxPyEndAllowThreads(__tstate);
11229 if (PyErr_Occurred()) SWIG_fail;
11230 }
11231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11232 {
11233 if (created1) delete arg1;
11234 }
11235 {
11236 if (temp2)
11237 delete arg2;
11238 }
11239 return resultobj;
11240 fail:
11241 {
11242 if (created1) delete arg1;
11243 }
11244 {
11245 if (temp2)
11246 delete arg2;
11247 }
11248 return NULL;
11249 }
11250
11251
11252 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11253 PyObject *resultobj;
11254 int arg1 = (int) 0 ;
11255 int arg2 = (int) 0 ;
11256 bool arg3 = (bool) true ;
11257 wxImage *result;
11258 PyObject * obj0 = 0 ;
11259 PyObject * obj1 = 0 ;
11260 PyObject * obj2 = 0 ;
11261 char *kwnames[] = {
11262 (char *) "width",(char *) "height",(char *) "clear", NULL
11263 };
11264
11265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11266 if (obj0) {
11267 {
11268 arg1 = (int)(SWIG_As_int(obj0));
11269 if (SWIG_arg_fail(1)) SWIG_fail;
11270 }
11271 }
11272 if (obj1) {
11273 {
11274 arg2 = (int)(SWIG_As_int(obj1));
11275 if (SWIG_arg_fail(2)) SWIG_fail;
11276 }
11277 }
11278 if (obj2) {
11279 {
11280 arg3 = (bool)(SWIG_As_bool(obj2));
11281 if (SWIG_arg_fail(3)) SWIG_fail;
11282 }
11283 }
11284 {
11285 PyThreadState* __tstate = wxPyBeginAllowThreads();
11286 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11287
11288 wxPyEndAllowThreads(__tstate);
11289 if (PyErr_Occurred()) SWIG_fail;
11290 }
11291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11292 return resultobj;
11293 fail:
11294 return NULL;
11295 }
11296
11297
11298 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11299 PyObject *resultobj;
11300 wxBitmap *arg1 = 0 ;
11301 wxImage *result;
11302 PyObject * obj0 = 0 ;
11303 char *kwnames[] = {
11304 (char *) "bitmap", NULL
11305 };
11306
11307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11308 {
11309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11310 if (SWIG_arg_fail(1)) SWIG_fail;
11311 if (arg1 == NULL) {
11312 SWIG_null_ref("wxBitmap");
11313 }
11314 if (SWIG_arg_fail(1)) SWIG_fail;
11315 }
11316 {
11317 if (!wxPyCheckForApp()) SWIG_fail;
11318 PyThreadState* __tstate = wxPyBeginAllowThreads();
11319 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11320
11321 wxPyEndAllowThreads(__tstate);
11322 if (PyErr_Occurred()) SWIG_fail;
11323 }
11324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11325 return resultobj;
11326 fail:
11327 return NULL;
11328 }
11329
11330
11331 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11332 PyObject *resultobj;
11333 int arg1 ;
11334 int arg2 ;
11335 buffer arg3 ;
11336 int arg4 ;
11337 wxImage *result;
11338 PyObject * obj0 = 0 ;
11339 PyObject * obj1 = 0 ;
11340 PyObject * obj2 = 0 ;
11341 char *kwnames[] = {
11342 (char *) "width",(char *) "height",(char *) "data", NULL
11343 };
11344
11345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11346 {
11347 arg1 = (int)(SWIG_As_int(obj0));
11348 if (SWIG_arg_fail(1)) SWIG_fail;
11349 }
11350 {
11351 arg2 = (int)(SWIG_As_int(obj1));
11352 if (SWIG_arg_fail(2)) SWIG_fail;
11353 }
11354 {
11355 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11356 }
11357 {
11358 PyThreadState* __tstate = wxPyBeginAllowThreads();
11359 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11360
11361 wxPyEndAllowThreads(__tstate);
11362 if (PyErr_Occurred()) SWIG_fail;
11363 }
11364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11365 return resultobj;
11366 fail:
11367 return NULL;
11368 }
11369
11370
11371 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11372 PyObject *resultobj;
11373 int arg1 ;
11374 int arg2 ;
11375 buffer arg3 ;
11376 int arg4 ;
11377 buffer arg5 ;
11378 int arg6 ;
11379 wxImage *result;
11380 PyObject * obj0 = 0 ;
11381 PyObject * obj1 = 0 ;
11382 PyObject * obj2 = 0 ;
11383 PyObject * obj3 = 0 ;
11384 char *kwnames[] = {
11385 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11386 };
11387
11388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11389 {
11390 arg1 = (int)(SWIG_As_int(obj0));
11391 if (SWIG_arg_fail(1)) SWIG_fail;
11392 }
11393 {
11394 arg2 = (int)(SWIG_As_int(obj1));
11395 if (SWIG_arg_fail(2)) SWIG_fail;
11396 }
11397 {
11398 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11399 }
11400 {
11401 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11402 }
11403 {
11404 PyThreadState* __tstate = wxPyBeginAllowThreads();
11405 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11406
11407 wxPyEndAllowThreads(__tstate);
11408 if (PyErr_Occurred()) SWIG_fail;
11409 }
11410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11411 return resultobj;
11412 fail:
11413 return NULL;
11414 }
11415
11416
11417 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11418 PyObject *resultobj;
11419 wxImage *arg1 = (wxImage *) 0 ;
11420 int arg2 ;
11421 int arg3 ;
11422 bool arg4 = (bool) true ;
11423 PyObject * obj0 = 0 ;
11424 PyObject * obj1 = 0 ;
11425 PyObject * obj2 = 0 ;
11426 PyObject * obj3 = 0 ;
11427 char *kwnames[] = {
11428 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11429 };
11430
11431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11433 if (SWIG_arg_fail(1)) SWIG_fail;
11434 {
11435 arg2 = (int)(SWIG_As_int(obj1));
11436 if (SWIG_arg_fail(2)) SWIG_fail;
11437 }
11438 {
11439 arg3 = (int)(SWIG_As_int(obj2));
11440 if (SWIG_arg_fail(3)) SWIG_fail;
11441 }
11442 if (obj3) {
11443 {
11444 arg4 = (bool)(SWIG_As_bool(obj3));
11445 if (SWIG_arg_fail(4)) SWIG_fail;
11446 }
11447 }
11448 {
11449 PyThreadState* __tstate = wxPyBeginAllowThreads();
11450 (arg1)->Create(arg2,arg3,arg4);
11451
11452 wxPyEndAllowThreads(__tstate);
11453 if (PyErr_Occurred()) SWIG_fail;
11454 }
11455 Py_INCREF(Py_None); resultobj = Py_None;
11456 return resultobj;
11457 fail:
11458 return NULL;
11459 }
11460
11461
11462 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11463 PyObject *resultobj;
11464 wxImage *arg1 = (wxImage *) 0 ;
11465 PyObject * obj0 = 0 ;
11466 char *kwnames[] = {
11467 (char *) "self", NULL
11468 };
11469
11470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11472 if (SWIG_arg_fail(1)) SWIG_fail;
11473 {
11474 PyThreadState* __tstate = wxPyBeginAllowThreads();
11475 (arg1)->Destroy();
11476
11477 wxPyEndAllowThreads(__tstate);
11478 if (PyErr_Occurred()) SWIG_fail;
11479 }
11480 Py_INCREF(Py_None); resultobj = Py_None;
11481 return resultobj;
11482 fail:
11483 return NULL;
11484 }
11485
11486
11487 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11488 PyObject *resultobj;
11489 wxImage *arg1 = (wxImage *) 0 ;
11490 int arg2 ;
11491 int arg3 ;
11492 SwigValueWrapper<wxImage > result;
11493 PyObject * obj0 = 0 ;
11494 PyObject * obj1 = 0 ;
11495 PyObject * obj2 = 0 ;
11496 char *kwnames[] = {
11497 (char *) "self",(char *) "width",(char *) "height", NULL
11498 };
11499
11500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11502 if (SWIG_arg_fail(1)) SWIG_fail;
11503 {
11504 arg2 = (int)(SWIG_As_int(obj1));
11505 if (SWIG_arg_fail(2)) SWIG_fail;
11506 }
11507 {
11508 arg3 = (int)(SWIG_As_int(obj2));
11509 if (SWIG_arg_fail(3)) SWIG_fail;
11510 }
11511 {
11512 PyThreadState* __tstate = wxPyBeginAllowThreads();
11513 result = (arg1)->Scale(arg2,arg3);
11514
11515 wxPyEndAllowThreads(__tstate);
11516 if (PyErr_Occurred()) SWIG_fail;
11517 }
11518 {
11519 wxImage * resultptr;
11520 resultptr = new wxImage((wxImage &)(result));
11521 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11522 }
11523 return resultobj;
11524 fail:
11525 return NULL;
11526 }
11527
11528
11529 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj;
11531 wxImage *arg1 = (wxImage *) 0 ;
11532 int arg2 ;
11533 int arg3 ;
11534 SwigValueWrapper<wxImage > result;
11535 PyObject * obj0 = 0 ;
11536 PyObject * obj1 = 0 ;
11537 PyObject * obj2 = 0 ;
11538 char *kwnames[] = {
11539 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11540 };
11541
11542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11544 if (SWIG_arg_fail(1)) SWIG_fail;
11545 {
11546 arg2 = (int)(SWIG_As_int(obj1));
11547 if (SWIG_arg_fail(2)) SWIG_fail;
11548 }
11549 {
11550 arg3 = (int)(SWIG_As_int(obj2));
11551 if (SWIG_arg_fail(3)) SWIG_fail;
11552 }
11553 {
11554 PyThreadState* __tstate = wxPyBeginAllowThreads();
11555 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11556
11557 wxPyEndAllowThreads(__tstate);
11558 if (PyErr_Occurred()) SWIG_fail;
11559 }
11560 {
11561 wxImage * resultptr;
11562 resultptr = new wxImage((wxImage &)(result));
11563 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11564 }
11565 return resultobj;
11566 fail:
11567 return NULL;
11568 }
11569
11570
11571 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11572 PyObject *resultobj;
11573 wxImage *arg1 = (wxImage *) 0 ;
11574 int arg2 ;
11575 int arg3 ;
11576 wxImage *result;
11577 PyObject * obj0 = 0 ;
11578 PyObject * obj1 = 0 ;
11579 PyObject * obj2 = 0 ;
11580 char *kwnames[] = {
11581 (char *) "self",(char *) "width",(char *) "height", NULL
11582 };
11583
11584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11586 if (SWIG_arg_fail(1)) SWIG_fail;
11587 {
11588 arg2 = (int)(SWIG_As_int(obj1));
11589 if (SWIG_arg_fail(2)) SWIG_fail;
11590 }
11591 {
11592 arg3 = (int)(SWIG_As_int(obj2));
11593 if (SWIG_arg_fail(3)) SWIG_fail;
11594 }
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 {
11598 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11599 result = (wxImage *) &_result_ref;
11600 }
11601
11602 wxPyEndAllowThreads(__tstate);
11603 if (PyErr_Occurred()) SWIG_fail;
11604 }
11605 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11606 return resultobj;
11607 fail:
11608 return NULL;
11609 }
11610
11611
11612 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11613 PyObject *resultobj;
11614 wxImage *arg1 = (wxImage *) 0 ;
11615 wxSize *arg2 = 0 ;
11616 wxPoint *arg3 = 0 ;
11617 int arg4 = (int) -1 ;
11618 int arg5 = (int) -1 ;
11619 int arg6 = (int) -1 ;
11620 wxImage *result;
11621 wxSize temp2 ;
11622 wxPoint temp3 ;
11623 PyObject * obj0 = 0 ;
11624 PyObject * obj1 = 0 ;
11625 PyObject * obj2 = 0 ;
11626 PyObject * obj3 = 0 ;
11627 PyObject * obj4 = 0 ;
11628 PyObject * obj5 = 0 ;
11629 char *kwnames[] = {
11630 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11631 };
11632
11633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11635 if (SWIG_arg_fail(1)) SWIG_fail;
11636 {
11637 arg2 = &temp2;
11638 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11639 }
11640 {
11641 arg3 = &temp3;
11642 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11643 }
11644 if (obj3) {
11645 {
11646 arg4 = (int)(SWIG_As_int(obj3));
11647 if (SWIG_arg_fail(4)) SWIG_fail;
11648 }
11649 }
11650 if (obj4) {
11651 {
11652 arg5 = (int)(SWIG_As_int(obj4));
11653 if (SWIG_arg_fail(5)) SWIG_fail;
11654 }
11655 }
11656 if (obj5) {
11657 {
11658 arg6 = (int)(SWIG_As_int(obj5));
11659 if (SWIG_arg_fail(6)) SWIG_fail;
11660 }
11661 }
11662 {
11663 PyThreadState* __tstate = wxPyBeginAllowThreads();
11664 {
11665 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11666 result = (wxImage *) &_result_ref;
11667 }
11668
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11673 return resultobj;
11674 fail:
11675 return NULL;
11676 }
11677
11678
11679 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11680 PyObject *resultobj;
11681 wxImage *arg1 = (wxImage *) 0 ;
11682 int arg2 ;
11683 int arg3 ;
11684 byte arg4 ;
11685 byte arg5 ;
11686 byte arg6 ;
11687 PyObject * obj0 = 0 ;
11688 PyObject * obj1 = 0 ;
11689 PyObject * obj2 = 0 ;
11690 PyObject * obj3 = 0 ;
11691 PyObject * obj4 = 0 ;
11692 PyObject * obj5 = 0 ;
11693 char *kwnames[] = {
11694 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11695 };
11696
11697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11699 if (SWIG_arg_fail(1)) SWIG_fail;
11700 {
11701 arg2 = (int)(SWIG_As_int(obj1));
11702 if (SWIG_arg_fail(2)) SWIG_fail;
11703 }
11704 {
11705 arg3 = (int)(SWIG_As_int(obj2));
11706 if (SWIG_arg_fail(3)) SWIG_fail;
11707 }
11708 {
11709 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11710 if (SWIG_arg_fail(4)) SWIG_fail;
11711 }
11712 {
11713 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11714 if (SWIG_arg_fail(5)) SWIG_fail;
11715 }
11716 {
11717 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
11718 if (SWIG_arg_fail(6)) SWIG_fail;
11719 }
11720 {
11721 PyThreadState* __tstate = wxPyBeginAllowThreads();
11722 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11723
11724 wxPyEndAllowThreads(__tstate);
11725 if (PyErr_Occurred()) SWIG_fail;
11726 }
11727 Py_INCREF(Py_None); resultobj = Py_None;
11728 return resultobj;
11729 fail:
11730 return NULL;
11731 }
11732
11733
11734 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11735 PyObject *resultobj;
11736 wxImage *arg1 = (wxImage *) 0 ;
11737 wxRect *arg2 = 0 ;
11738 byte arg3 ;
11739 byte arg4 ;
11740 byte arg5 ;
11741 wxRect temp2 ;
11742 PyObject * obj0 = 0 ;
11743 PyObject * obj1 = 0 ;
11744 PyObject * obj2 = 0 ;
11745 PyObject * obj3 = 0 ;
11746 PyObject * obj4 = 0 ;
11747 char *kwnames[] = {
11748 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11749 };
11750
11751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11753 if (SWIG_arg_fail(1)) SWIG_fail;
11754 {
11755 arg2 = &temp2;
11756 if ( ! wxRect_helper(obj1, &arg2)) 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 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11773
11774 wxPyEndAllowThreads(__tstate);
11775 if (PyErr_Occurred()) SWIG_fail;
11776 }
11777 Py_INCREF(Py_None); resultobj = Py_None;
11778 return resultobj;
11779 fail:
11780 return NULL;
11781 }
11782
11783
11784 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11785 PyObject *resultobj;
11786 wxImage *arg1 = (wxImage *) 0 ;
11787 int arg2 ;
11788 int arg3 ;
11789 byte result;
11790 PyObject * obj0 = 0 ;
11791 PyObject * obj1 = 0 ;
11792 PyObject * obj2 = 0 ;
11793 char *kwnames[] = {
11794 (char *) "self",(char *) "x",(char *) "y", NULL
11795 };
11796
11797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11799 if (SWIG_arg_fail(1)) SWIG_fail;
11800 {
11801 arg2 = (int)(SWIG_As_int(obj1));
11802 if (SWIG_arg_fail(2)) SWIG_fail;
11803 }
11804 {
11805 arg3 = (int)(SWIG_As_int(obj2));
11806 if (SWIG_arg_fail(3)) SWIG_fail;
11807 }
11808 {
11809 PyThreadState* __tstate = wxPyBeginAllowThreads();
11810 result = (byte)(arg1)->GetRed(arg2,arg3);
11811
11812 wxPyEndAllowThreads(__tstate);
11813 if (PyErr_Occurred()) SWIG_fail;
11814 }
11815 {
11816 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11817 }
11818 return resultobj;
11819 fail:
11820 return NULL;
11821 }
11822
11823
11824 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11825 PyObject *resultobj;
11826 wxImage *arg1 = (wxImage *) 0 ;
11827 int arg2 ;
11828 int arg3 ;
11829 byte result;
11830 PyObject * obj0 = 0 ;
11831 PyObject * obj1 = 0 ;
11832 PyObject * obj2 = 0 ;
11833 char *kwnames[] = {
11834 (char *) "self",(char *) "x",(char *) "y", NULL
11835 };
11836
11837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11839 if (SWIG_arg_fail(1)) SWIG_fail;
11840 {
11841 arg2 = (int)(SWIG_As_int(obj1));
11842 if (SWIG_arg_fail(2)) SWIG_fail;
11843 }
11844 {
11845 arg3 = (int)(SWIG_As_int(obj2));
11846 if (SWIG_arg_fail(3)) SWIG_fail;
11847 }
11848 {
11849 PyThreadState* __tstate = wxPyBeginAllowThreads();
11850 result = (byte)(arg1)->GetGreen(arg2,arg3);
11851
11852 wxPyEndAllowThreads(__tstate);
11853 if (PyErr_Occurred()) SWIG_fail;
11854 }
11855 {
11856 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11857 }
11858 return resultobj;
11859 fail:
11860 return NULL;
11861 }
11862
11863
11864 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11865 PyObject *resultobj;
11866 wxImage *arg1 = (wxImage *) 0 ;
11867 int arg2 ;
11868 int arg3 ;
11869 byte result;
11870 PyObject * obj0 = 0 ;
11871 PyObject * obj1 = 0 ;
11872 PyObject * obj2 = 0 ;
11873 char *kwnames[] = {
11874 (char *) "self",(char *) "x",(char *) "y", NULL
11875 };
11876
11877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11879 if (SWIG_arg_fail(1)) SWIG_fail;
11880 {
11881 arg2 = (int)(SWIG_As_int(obj1));
11882 if (SWIG_arg_fail(2)) SWIG_fail;
11883 }
11884 {
11885 arg3 = (int)(SWIG_As_int(obj2));
11886 if (SWIG_arg_fail(3)) SWIG_fail;
11887 }
11888 {
11889 PyThreadState* __tstate = wxPyBeginAllowThreads();
11890 result = (byte)(arg1)->GetBlue(arg2,arg3);
11891
11892 wxPyEndAllowThreads(__tstate);
11893 if (PyErr_Occurred()) SWIG_fail;
11894 }
11895 {
11896 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11897 }
11898 return resultobj;
11899 fail:
11900 return NULL;
11901 }
11902
11903
11904 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11905 PyObject *resultobj;
11906 wxImage *arg1 = (wxImage *) 0 ;
11907 int arg2 ;
11908 int arg3 ;
11909 byte arg4 ;
11910 PyObject * obj0 = 0 ;
11911 PyObject * obj1 = 0 ;
11912 PyObject * obj2 = 0 ;
11913 PyObject * obj3 = 0 ;
11914 char *kwnames[] = {
11915 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11916 };
11917
11918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11920 if (SWIG_arg_fail(1)) SWIG_fail;
11921 {
11922 arg2 = (int)(SWIG_As_int(obj1));
11923 if (SWIG_arg_fail(2)) SWIG_fail;
11924 }
11925 {
11926 arg3 = (int)(SWIG_As_int(obj2));
11927 if (SWIG_arg_fail(3)) SWIG_fail;
11928 }
11929 {
11930 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11931 if (SWIG_arg_fail(4)) SWIG_fail;
11932 }
11933 {
11934 PyThreadState* __tstate = wxPyBeginAllowThreads();
11935 (arg1)->SetAlpha(arg2,arg3,arg4);
11936
11937 wxPyEndAllowThreads(__tstate);
11938 if (PyErr_Occurred()) SWIG_fail;
11939 }
11940 Py_INCREF(Py_None); resultobj = Py_None;
11941 return resultobj;
11942 fail:
11943 return NULL;
11944 }
11945
11946
11947 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj;
11949 wxImage *arg1 = (wxImage *) 0 ;
11950 int arg2 ;
11951 int arg3 ;
11952 byte result;
11953 PyObject * obj0 = 0 ;
11954 PyObject * obj1 = 0 ;
11955 PyObject * obj2 = 0 ;
11956 char *kwnames[] = {
11957 (char *) "self",(char *) "x",(char *) "y", NULL
11958 };
11959
11960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11962 if (SWIG_arg_fail(1)) SWIG_fail;
11963 {
11964 arg2 = (int)(SWIG_As_int(obj1));
11965 if (SWIG_arg_fail(2)) SWIG_fail;
11966 }
11967 {
11968 arg3 = (int)(SWIG_As_int(obj2));
11969 if (SWIG_arg_fail(3)) SWIG_fail;
11970 }
11971 {
11972 PyThreadState* __tstate = wxPyBeginAllowThreads();
11973 result = (byte)(arg1)->GetAlpha(arg2,arg3);
11974
11975 wxPyEndAllowThreads(__tstate);
11976 if (PyErr_Occurred()) SWIG_fail;
11977 }
11978 {
11979 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11980 }
11981 return resultobj;
11982 fail:
11983 return NULL;
11984 }
11985
11986
11987 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11988 PyObject *resultobj;
11989 wxImage *arg1 = (wxImage *) 0 ;
11990 bool result;
11991 PyObject * obj0 = 0 ;
11992 char *kwnames[] = {
11993 (char *) "self", NULL
11994 };
11995
11996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11998 if (SWIG_arg_fail(1)) SWIG_fail;
11999 {
12000 PyThreadState* __tstate = wxPyBeginAllowThreads();
12001 result = (bool)(arg1)->HasAlpha();
12002
12003 wxPyEndAllowThreads(__tstate);
12004 if (PyErr_Occurred()) SWIG_fail;
12005 }
12006 {
12007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12008 }
12009 return resultobj;
12010 fail:
12011 return NULL;
12012 }
12013
12014
12015 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12016 PyObject *resultobj;
12017 wxImage *arg1 = (wxImage *) 0 ;
12018 PyObject * obj0 = 0 ;
12019 char *kwnames[] = {
12020 (char *) "self", NULL
12021 };
12022
12023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
12024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12025 if (SWIG_arg_fail(1)) SWIG_fail;
12026 {
12027 PyThreadState* __tstate = wxPyBeginAllowThreads();
12028 (arg1)->InitAlpha();
12029
12030 wxPyEndAllowThreads(__tstate);
12031 if (PyErr_Occurred()) SWIG_fail;
12032 }
12033 Py_INCREF(Py_None); resultobj = Py_None;
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj;
12042 wxImage *arg1 = (wxImage *) 0 ;
12043 int arg2 ;
12044 int arg3 ;
12045 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12046 bool result;
12047 PyObject * obj0 = 0 ;
12048 PyObject * obj1 = 0 ;
12049 PyObject * obj2 = 0 ;
12050 PyObject * obj3 = 0 ;
12051 char *kwnames[] = {
12052 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12053 };
12054
12055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12057 if (SWIG_arg_fail(1)) SWIG_fail;
12058 {
12059 arg2 = (int)(SWIG_As_int(obj1));
12060 if (SWIG_arg_fail(2)) SWIG_fail;
12061 }
12062 {
12063 arg3 = (int)(SWIG_As_int(obj2));
12064 if (SWIG_arg_fail(3)) SWIG_fail;
12065 }
12066 if (obj3) {
12067 {
12068 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12069 if (SWIG_arg_fail(4)) SWIG_fail;
12070 }
12071 }
12072 {
12073 PyThreadState* __tstate = wxPyBeginAllowThreads();
12074 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12075
12076 wxPyEndAllowThreads(__tstate);
12077 if (PyErr_Occurred()) SWIG_fail;
12078 }
12079 {
12080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12081 }
12082 return resultobj;
12083 fail:
12084 return NULL;
12085 }
12086
12087
12088 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12089 PyObject *resultobj;
12090 wxImage *arg1 = (wxImage *) 0 ;
12091 byte *arg2 = (byte *) 0 ;
12092 byte *arg3 = (byte *) 0 ;
12093 byte *arg4 = (byte *) 0 ;
12094 byte arg5 = (byte) 0 ;
12095 byte arg6 = (byte) 0 ;
12096 byte arg7 = (byte) 0 ;
12097 bool result;
12098 byte temp2 ;
12099 int res2 = 0 ;
12100 byte temp3 ;
12101 int res3 = 0 ;
12102 byte temp4 ;
12103 int res4 = 0 ;
12104 PyObject * obj0 = 0 ;
12105 PyObject * obj1 = 0 ;
12106 PyObject * obj2 = 0 ;
12107 PyObject * obj3 = 0 ;
12108 char *kwnames[] = {
12109 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12110 };
12111
12112 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12113 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12114 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12117 if (SWIG_arg_fail(1)) SWIG_fail;
12118 if (obj1) {
12119 {
12120 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12121 if (SWIG_arg_fail(5)) SWIG_fail;
12122 }
12123 }
12124 if (obj2) {
12125 {
12126 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12127 if (SWIG_arg_fail(6)) SWIG_fail;
12128 }
12129 }
12130 if (obj3) {
12131 {
12132 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12133 if (SWIG_arg_fail(7)) SWIG_fail;
12134 }
12135 }
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12139
12140 wxPyEndAllowThreads(__tstate);
12141 if (PyErr_Occurred()) SWIG_fail;
12142 }
12143 {
12144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12145 }
12146 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12147 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12148 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12149 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12150 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12151 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12152 return resultobj;
12153 fail:
12154 return NULL;
12155 }
12156
12157
12158 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12159 PyObject *resultobj;
12160 wxImage *arg1 = (wxImage *) 0 ;
12161 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12162 bool result;
12163 PyObject * obj0 = 0 ;
12164 PyObject * obj1 = 0 ;
12165 char *kwnames[] = {
12166 (char *) "self",(char *) "threshold", NULL
12167 };
12168
12169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12171 if (SWIG_arg_fail(1)) SWIG_fail;
12172 if (obj1) {
12173 {
12174 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12175 if (SWIG_arg_fail(2)) SWIG_fail;
12176 }
12177 }
12178 {
12179 PyThreadState* __tstate = wxPyBeginAllowThreads();
12180 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12181
12182 wxPyEndAllowThreads(__tstate);
12183 if (PyErr_Occurred()) SWIG_fail;
12184 }
12185 {
12186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12187 }
12188 return resultobj;
12189 fail:
12190 return NULL;
12191 }
12192
12193
12194 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12195 PyObject *resultobj;
12196 wxImage *arg1 = (wxImage *) 0 ;
12197 byte arg2 ;
12198 byte arg3 ;
12199 byte arg4 ;
12200 bool result;
12201 PyObject * obj0 = 0 ;
12202 PyObject * obj1 = 0 ;
12203 PyObject * obj2 = 0 ;
12204 PyObject * obj3 = 0 ;
12205 char *kwnames[] = {
12206 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12207 };
12208
12209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12211 if (SWIG_arg_fail(1)) SWIG_fail;
12212 {
12213 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12214 if (SWIG_arg_fail(2)) SWIG_fail;
12215 }
12216 {
12217 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12218 if (SWIG_arg_fail(3)) SWIG_fail;
12219 }
12220 {
12221 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12222 if (SWIG_arg_fail(4)) SWIG_fail;
12223 }
12224 {
12225 PyThreadState* __tstate = wxPyBeginAllowThreads();
12226 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12227
12228 wxPyEndAllowThreads(__tstate);
12229 if (PyErr_Occurred()) SWIG_fail;
12230 }
12231 {
12232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12233 }
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12241 PyObject *resultobj;
12242 wxImage *arg1 = (wxImage *) 0 ;
12243 wxImage *arg2 = 0 ;
12244 byte arg3 ;
12245 byte arg4 ;
12246 byte arg5 ;
12247 bool result;
12248 PyObject * obj0 = 0 ;
12249 PyObject * obj1 = 0 ;
12250 PyObject * obj2 = 0 ;
12251 PyObject * obj3 = 0 ;
12252 PyObject * obj4 = 0 ;
12253 char *kwnames[] = {
12254 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12255 };
12256
12257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12259 if (SWIG_arg_fail(1)) SWIG_fail;
12260 {
12261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12262 if (SWIG_arg_fail(2)) SWIG_fail;
12263 if (arg2 == NULL) {
12264 SWIG_null_ref("wxImage");
12265 }
12266 if (SWIG_arg_fail(2)) SWIG_fail;
12267 }
12268 {
12269 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12270 if (SWIG_arg_fail(3)) SWIG_fail;
12271 }
12272 {
12273 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12274 if (SWIG_arg_fail(4)) SWIG_fail;
12275 }
12276 {
12277 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
12278 if (SWIG_arg_fail(5)) SWIG_fail;
12279 }
12280 {
12281 PyThreadState* __tstate = wxPyBeginAllowThreads();
12282 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12283
12284 wxPyEndAllowThreads(__tstate);
12285 if (PyErr_Occurred()) SWIG_fail;
12286 }
12287 {
12288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12289 }
12290 return resultobj;
12291 fail:
12292 return NULL;
12293 }
12294
12295
12296 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12297 PyObject *resultobj;
12298 wxString *arg1 = 0 ;
12299 bool result;
12300 bool temp1 = false ;
12301 PyObject * obj0 = 0 ;
12302 char *kwnames[] = {
12303 (char *) "filename", NULL
12304 };
12305
12306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12307 {
12308 arg1 = wxString_in_helper(obj0);
12309 if (arg1 == NULL) SWIG_fail;
12310 temp1 = true;
12311 }
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
12314 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12315
12316 wxPyEndAllowThreads(__tstate);
12317 if (PyErr_Occurred()) SWIG_fail;
12318 }
12319 {
12320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12321 }
12322 {
12323 if (temp1)
12324 delete arg1;
12325 }
12326 return resultobj;
12327 fail:
12328 {
12329 if (temp1)
12330 delete arg1;
12331 }
12332 return NULL;
12333 }
12334
12335
12336 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12337 PyObject *resultobj;
12338 wxString *arg1 = 0 ;
12339 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12340 int result;
12341 bool temp1 = false ;
12342 PyObject * obj0 = 0 ;
12343 PyObject * obj1 = 0 ;
12344 char *kwnames[] = {
12345 (char *) "filename",(char *) "type", NULL
12346 };
12347
12348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12349 {
12350 arg1 = wxString_in_helper(obj0);
12351 if (arg1 == NULL) SWIG_fail;
12352 temp1 = true;
12353 }
12354 if (obj1) {
12355 {
12356 arg2 = (long)(SWIG_As_long(obj1));
12357 if (SWIG_arg_fail(2)) SWIG_fail;
12358 }
12359 }
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12363
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 {
12368 resultobj = SWIG_From_int((int)(result));
12369 }
12370 {
12371 if (temp1)
12372 delete arg1;
12373 }
12374 return resultobj;
12375 fail:
12376 {
12377 if (temp1)
12378 delete arg1;
12379 }
12380 return NULL;
12381 }
12382
12383
12384 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12385 PyObject *resultobj;
12386 wxImage *arg1 = (wxImage *) 0 ;
12387 wxString *arg2 = 0 ;
12388 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12389 int arg4 = (int) -1 ;
12390 bool result;
12391 bool temp2 = false ;
12392 PyObject * obj0 = 0 ;
12393 PyObject * obj1 = 0 ;
12394 PyObject * obj2 = 0 ;
12395 PyObject * obj3 = 0 ;
12396 char *kwnames[] = {
12397 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12398 };
12399
12400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12402 if (SWIG_arg_fail(1)) SWIG_fail;
12403 {
12404 arg2 = wxString_in_helper(obj1);
12405 if (arg2 == NULL) SWIG_fail;
12406 temp2 = true;
12407 }
12408 if (obj2) {
12409 {
12410 arg3 = (long)(SWIG_As_long(obj2));
12411 if (SWIG_arg_fail(3)) SWIG_fail;
12412 }
12413 }
12414 if (obj3) {
12415 {
12416 arg4 = (int)(SWIG_As_int(obj3));
12417 if (SWIG_arg_fail(4)) SWIG_fail;
12418 }
12419 }
12420 {
12421 PyThreadState* __tstate = wxPyBeginAllowThreads();
12422 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12423
12424 wxPyEndAllowThreads(__tstate);
12425 if (PyErr_Occurred()) SWIG_fail;
12426 }
12427 {
12428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12429 }
12430 {
12431 if (temp2)
12432 delete arg2;
12433 }
12434 return resultobj;
12435 fail:
12436 {
12437 if (temp2)
12438 delete arg2;
12439 }
12440 return NULL;
12441 }
12442
12443
12444 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12445 PyObject *resultobj;
12446 wxImage *arg1 = (wxImage *) 0 ;
12447 wxString *arg2 = 0 ;
12448 wxString *arg3 = 0 ;
12449 int arg4 = (int) -1 ;
12450 bool result;
12451 bool temp2 = false ;
12452 bool temp3 = false ;
12453 PyObject * obj0 = 0 ;
12454 PyObject * obj1 = 0 ;
12455 PyObject * obj2 = 0 ;
12456 PyObject * obj3 = 0 ;
12457 char *kwnames[] = {
12458 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12459 };
12460
12461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12463 if (SWIG_arg_fail(1)) SWIG_fail;
12464 {
12465 arg2 = wxString_in_helper(obj1);
12466 if (arg2 == NULL) SWIG_fail;
12467 temp2 = true;
12468 }
12469 {
12470 arg3 = wxString_in_helper(obj2);
12471 if (arg3 == NULL) SWIG_fail;
12472 temp3 = true;
12473 }
12474 if (obj3) {
12475 {
12476 arg4 = (int)(SWIG_As_int(obj3));
12477 if (SWIG_arg_fail(4)) SWIG_fail;
12478 }
12479 }
12480 {
12481 PyThreadState* __tstate = wxPyBeginAllowThreads();
12482 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12483
12484 wxPyEndAllowThreads(__tstate);
12485 if (PyErr_Occurred()) SWIG_fail;
12486 }
12487 {
12488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12489 }
12490 {
12491 if (temp2)
12492 delete arg2;
12493 }
12494 {
12495 if (temp3)
12496 delete arg3;
12497 }
12498 return resultobj;
12499 fail:
12500 {
12501 if (temp2)
12502 delete arg2;
12503 }
12504 {
12505 if (temp3)
12506 delete arg3;
12507 }
12508 return NULL;
12509 }
12510
12511
12512 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12513 PyObject *resultobj;
12514 wxImage *arg1 = (wxImage *) 0 ;
12515 wxString *arg2 = 0 ;
12516 int arg3 ;
12517 bool result;
12518 bool temp2 = false ;
12519 PyObject * obj0 = 0 ;
12520 PyObject * obj1 = 0 ;
12521 PyObject * obj2 = 0 ;
12522 char *kwnames[] = {
12523 (char *) "self",(char *) "name",(char *) "type", NULL
12524 };
12525
12526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12528 if (SWIG_arg_fail(1)) SWIG_fail;
12529 {
12530 arg2 = wxString_in_helper(obj1);
12531 if (arg2 == NULL) SWIG_fail;
12532 temp2 = true;
12533 }
12534 {
12535 arg3 = (int)(SWIG_As_int(obj2));
12536 if (SWIG_arg_fail(3)) SWIG_fail;
12537 }
12538 {
12539 PyThreadState* __tstate = wxPyBeginAllowThreads();
12540 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12541
12542 wxPyEndAllowThreads(__tstate);
12543 if (PyErr_Occurred()) SWIG_fail;
12544 }
12545 {
12546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12547 }
12548 {
12549 if (temp2)
12550 delete arg2;
12551 }
12552 return resultobj;
12553 fail:
12554 {
12555 if (temp2)
12556 delete arg2;
12557 }
12558 return NULL;
12559 }
12560
12561
12562 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12563 PyObject *resultobj;
12564 wxImage *arg1 = (wxImage *) 0 ;
12565 wxString *arg2 = 0 ;
12566 wxString *arg3 = 0 ;
12567 bool result;
12568 bool temp2 = false ;
12569 bool temp3 = false ;
12570 PyObject * obj0 = 0 ;
12571 PyObject * obj1 = 0 ;
12572 PyObject * obj2 = 0 ;
12573 char *kwnames[] = {
12574 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12575 };
12576
12577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12579 if (SWIG_arg_fail(1)) SWIG_fail;
12580 {
12581 arg2 = wxString_in_helper(obj1);
12582 if (arg2 == NULL) SWIG_fail;
12583 temp2 = true;
12584 }
12585 {
12586 arg3 = wxString_in_helper(obj2);
12587 if (arg3 == NULL) SWIG_fail;
12588 temp3 = true;
12589 }
12590 {
12591 PyThreadState* __tstate = wxPyBeginAllowThreads();
12592 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12593
12594 wxPyEndAllowThreads(__tstate);
12595 if (PyErr_Occurred()) SWIG_fail;
12596 }
12597 {
12598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12599 }
12600 {
12601 if (temp2)
12602 delete arg2;
12603 }
12604 {
12605 if (temp3)
12606 delete arg3;
12607 }
12608 return resultobj;
12609 fail:
12610 {
12611 if (temp2)
12612 delete arg2;
12613 }
12614 {
12615 if (temp3)
12616 delete arg3;
12617 }
12618 return NULL;
12619 }
12620
12621
12622 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12623 PyObject *resultobj;
12624 wxInputStream *arg1 = 0 ;
12625 bool result;
12626 wxPyInputStream *temp1 ;
12627 bool created1 ;
12628 PyObject * obj0 = 0 ;
12629 char *kwnames[] = {
12630 (char *) "stream", NULL
12631 };
12632
12633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12634 {
12635 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12636 arg1 = temp1->m_wxis;
12637 created1 = false;
12638 } else {
12639 PyErr_Clear(); // clear the failure of the wxPyConvert above
12640 arg1 = wxPyCBInputStream_create(obj0, false);
12641 if (arg1 == NULL) {
12642 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12643 SWIG_fail;
12644 }
12645 created1 = true;
12646 }
12647 }
12648 {
12649 PyThreadState* __tstate = wxPyBeginAllowThreads();
12650 result = (bool)wxImage::CanRead(*arg1);
12651
12652 wxPyEndAllowThreads(__tstate);
12653 if (PyErr_Occurred()) SWIG_fail;
12654 }
12655 {
12656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12657 }
12658 {
12659 if (created1) delete arg1;
12660 }
12661 return resultobj;
12662 fail:
12663 {
12664 if (created1) delete arg1;
12665 }
12666 return NULL;
12667 }
12668
12669
12670 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12671 PyObject *resultobj;
12672 wxImage *arg1 = (wxImage *) 0 ;
12673 wxInputStream *arg2 = 0 ;
12674 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12675 int arg4 = (int) -1 ;
12676 bool result;
12677 wxPyInputStream *temp2 ;
12678 bool created2 ;
12679 PyObject * obj0 = 0 ;
12680 PyObject * obj1 = 0 ;
12681 PyObject * obj2 = 0 ;
12682 PyObject * obj3 = 0 ;
12683 char *kwnames[] = {
12684 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12685 };
12686
12687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12689 if (SWIG_arg_fail(1)) SWIG_fail;
12690 {
12691 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12692 arg2 = temp2->m_wxis;
12693 created2 = false;
12694 } else {
12695 PyErr_Clear(); // clear the failure of the wxPyConvert above
12696 arg2 = wxPyCBInputStream_create(obj1, false);
12697 if (arg2 == NULL) {
12698 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12699 SWIG_fail;
12700 }
12701 created2 = true;
12702 }
12703 }
12704 if (obj2) {
12705 {
12706 arg3 = (long)(SWIG_As_long(obj2));
12707 if (SWIG_arg_fail(3)) SWIG_fail;
12708 }
12709 }
12710 if (obj3) {
12711 {
12712 arg4 = (int)(SWIG_As_int(obj3));
12713 if (SWIG_arg_fail(4)) SWIG_fail;
12714 }
12715 }
12716 {
12717 PyThreadState* __tstate = wxPyBeginAllowThreads();
12718 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12719
12720 wxPyEndAllowThreads(__tstate);
12721 if (PyErr_Occurred()) SWIG_fail;
12722 }
12723 {
12724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12725 }
12726 {
12727 if (created2) delete arg2;
12728 }
12729 return resultobj;
12730 fail:
12731 {
12732 if (created2) delete arg2;
12733 }
12734 return NULL;
12735 }
12736
12737
12738 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12739 PyObject *resultobj;
12740 wxImage *arg1 = (wxImage *) 0 ;
12741 wxInputStream *arg2 = 0 ;
12742 wxString *arg3 = 0 ;
12743 int arg4 = (int) -1 ;
12744 bool result;
12745 wxPyInputStream *temp2 ;
12746 bool created2 ;
12747 bool temp3 = false ;
12748 PyObject * obj0 = 0 ;
12749 PyObject * obj1 = 0 ;
12750 PyObject * obj2 = 0 ;
12751 PyObject * obj3 = 0 ;
12752 char *kwnames[] = {
12753 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12754 };
12755
12756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12758 if (SWIG_arg_fail(1)) SWIG_fail;
12759 {
12760 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12761 arg2 = temp2->m_wxis;
12762 created2 = false;
12763 } else {
12764 PyErr_Clear(); // clear the failure of the wxPyConvert above
12765 arg2 = wxPyCBInputStream_create(obj1, false);
12766 if (arg2 == NULL) {
12767 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12768 SWIG_fail;
12769 }
12770 created2 = true;
12771 }
12772 }
12773 {
12774 arg3 = wxString_in_helper(obj2);
12775 if (arg3 == NULL) SWIG_fail;
12776 temp3 = true;
12777 }
12778 if (obj3) {
12779 {
12780 arg4 = (int)(SWIG_As_int(obj3));
12781 if (SWIG_arg_fail(4)) SWIG_fail;
12782 }
12783 }
12784 {
12785 PyThreadState* __tstate = wxPyBeginAllowThreads();
12786 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12787
12788 wxPyEndAllowThreads(__tstate);
12789 if (PyErr_Occurred()) SWIG_fail;
12790 }
12791 {
12792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12793 }
12794 {
12795 if (created2) delete arg2;
12796 }
12797 {
12798 if (temp3)
12799 delete arg3;
12800 }
12801 return resultobj;
12802 fail:
12803 {
12804 if (created2) delete arg2;
12805 }
12806 {
12807 if (temp3)
12808 delete arg3;
12809 }
12810 return NULL;
12811 }
12812
12813
12814 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12815 PyObject *resultobj;
12816 wxImage *arg1 = (wxImage *) 0 ;
12817 bool result;
12818 PyObject * obj0 = 0 ;
12819 char *kwnames[] = {
12820 (char *) "self", NULL
12821 };
12822
12823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12825 if (SWIG_arg_fail(1)) SWIG_fail;
12826 {
12827 PyThreadState* __tstate = wxPyBeginAllowThreads();
12828 result = (bool)(arg1)->Ok();
12829
12830 wxPyEndAllowThreads(__tstate);
12831 if (PyErr_Occurred()) SWIG_fail;
12832 }
12833 {
12834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12835 }
12836 return resultobj;
12837 fail:
12838 return NULL;
12839 }
12840
12841
12842 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12843 PyObject *resultobj;
12844 wxImage *arg1 = (wxImage *) 0 ;
12845 int result;
12846 PyObject * obj0 = 0 ;
12847 char *kwnames[] = {
12848 (char *) "self", NULL
12849 };
12850
12851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12853 if (SWIG_arg_fail(1)) SWIG_fail;
12854 {
12855 PyThreadState* __tstate = wxPyBeginAllowThreads();
12856 result = (int)(arg1)->GetWidth();
12857
12858 wxPyEndAllowThreads(__tstate);
12859 if (PyErr_Occurred()) SWIG_fail;
12860 }
12861 {
12862 resultobj = SWIG_From_int((int)(result));
12863 }
12864 return resultobj;
12865 fail:
12866 return NULL;
12867 }
12868
12869
12870 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12871 PyObject *resultobj;
12872 wxImage *arg1 = (wxImage *) 0 ;
12873 int result;
12874 PyObject * obj0 = 0 ;
12875 char *kwnames[] = {
12876 (char *) "self", NULL
12877 };
12878
12879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12881 if (SWIG_arg_fail(1)) SWIG_fail;
12882 {
12883 PyThreadState* __tstate = wxPyBeginAllowThreads();
12884 result = (int)(arg1)->GetHeight();
12885
12886 wxPyEndAllowThreads(__tstate);
12887 if (PyErr_Occurred()) SWIG_fail;
12888 }
12889 {
12890 resultobj = SWIG_From_int((int)(result));
12891 }
12892 return resultobj;
12893 fail:
12894 return NULL;
12895 }
12896
12897
12898 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12899 PyObject *resultobj;
12900 wxImage *arg1 = (wxImage *) 0 ;
12901 wxSize result;
12902 PyObject * obj0 = 0 ;
12903 char *kwnames[] = {
12904 (char *) "self", NULL
12905 };
12906
12907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12909 if (SWIG_arg_fail(1)) SWIG_fail;
12910 {
12911 PyThreadState* __tstate = wxPyBeginAllowThreads();
12912 result = wxImage_GetSize(arg1);
12913
12914 wxPyEndAllowThreads(__tstate);
12915 if (PyErr_Occurred()) SWIG_fail;
12916 }
12917 {
12918 wxSize * resultptr;
12919 resultptr = new wxSize((wxSize &)(result));
12920 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12921 }
12922 return resultobj;
12923 fail:
12924 return NULL;
12925 }
12926
12927
12928 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12929 PyObject *resultobj;
12930 wxImage *arg1 = (wxImage *) 0 ;
12931 wxRect *arg2 = 0 ;
12932 SwigValueWrapper<wxImage > result;
12933 wxRect temp2 ;
12934 PyObject * obj0 = 0 ;
12935 PyObject * obj1 = 0 ;
12936 char *kwnames[] = {
12937 (char *) "self",(char *) "rect", NULL
12938 };
12939
12940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12942 if (SWIG_arg_fail(1)) SWIG_fail;
12943 {
12944 arg2 = &temp2;
12945 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12946 }
12947 {
12948 PyThreadState* __tstate = wxPyBeginAllowThreads();
12949 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12950
12951 wxPyEndAllowThreads(__tstate);
12952 if (PyErr_Occurred()) SWIG_fail;
12953 }
12954 {
12955 wxImage * resultptr;
12956 resultptr = new wxImage((wxImage &)(result));
12957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12958 }
12959 return resultobj;
12960 fail:
12961 return NULL;
12962 }
12963
12964
12965 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12966 PyObject *resultobj;
12967 wxImage *arg1 = (wxImage *) 0 ;
12968 wxSize *arg2 = 0 ;
12969 wxPoint *arg3 = 0 ;
12970 int arg4 = (int) -1 ;
12971 int arg5 = (int) -1 ;
12972 int arg6 = (int) -1 ;
12973 SwigValueWrapper<wxImage > result;
12974 wxSize temp2 ;
12975 wxPoint temp3 ;
12976 PyObject * obj0 = 0 ;
12977 PyObject * obj1 = 0 ;
12978 PyObject * obj2 = 0 ;
12979 PyObject * obj3 = 0 ;
12980 PyObject * obj4 = 0 ;
12981 PyObject * obj5 = 0 ;
12982 char *kwnames[] = {
12983 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12984 };
12985
12986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12988 if (SWIG_arg_fail(1)) SWIG_fail;
12989 {
12990 arg2 = &temp2;
12991 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12992 }
12993 {
12994 arg3 = &temp3;
12995 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12996 }
12997 if (obj3) {
12998 {
12999 arg4 = (int)(SWIG_As_int(obj3));
13000 if (SWIG_arg_fail(4)) SWIG_fail;
13001 }
13002 }
13003 if (obj4) {
13004 {
13005 arg5 = (int)(SWIG_As_int(obj4));
13006 if (SWIG_arg_fail(5)) SWIG_fail;
13007 }
13008 }
13009 if (obj5) {
13010 {
13011 arg6 = (int)(SWIG_As_int(obj5));
13012 if (SWIG_arg_fail(6)) SWIG_fail;
13013 }
13014 }
13015 {
13016 PyThreadState* __tstate = wxPyBeginAllowThreads();
13017 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13018
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
13022 {
13023 wxImage * resultptr;
13024 resultptr = new wxImage((wxImage &)(result));
13025 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13026 }
13027 return resultobj;
13028 fail:
13029 return NULL;
13030 }
13031
13032
13033 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13034 PyObject *resultobj;
13035 wxImage *arg1 = (wxImage *) 0 ;
13036 SwigValueWrapper<wxImage > result;
13037 PyObject * obj0 = 0 ;
13038 char *kwnames[] = {
13039 (char *) "self", NULL
13040 };
13041
13042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13044 if (SWIG_arg_fail(1)) SWIG_fail;
13045 {
13046 PyThreadState* __tstate = wxPyBeginAllowThreads();
13047 result = (arg1)->Copy();
13048
13049 wxPyEndAllowThreads(__tstate);
13050 if (PyErr_Occurred()) SWIG_fail;
13051 }
13052 {
13053 wxImage * resultptr;
13054 resultptr = new wxImage((wxImage &)(result));
13055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13056 }
13057 return resultobj;
13058 fail:
13059 return NULL;
13060 }
13061
13062
13063 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13064 PyObject *resultobj;
13065 wxImage *arg1 = (wxImage *) 0 ;
13066 wxImage *arg2 = 0 ;
13067 int arg3 ;
13068 int arg4 ;
13069 PyObject * obj0 = 0 ;
13070 PyObject * obj1 = 0 ;
13071 PyObject * obj2 = 0 ;
13072 PyObject * obj3 = 0 ;
13073 char *kwnames[] = {
13074 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13075 };
13076
13077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13082 if (SWIG_arg_fail(2)) SWIG_fail;
13083 if (arg2 == NULL) {
13084 SWIG_null_ref("wxImage");
13085 }
13086 if (SWIG_arg_fail(2)) SWIG_fail;
13087 }
13088 {
13089 arg3 = (int)(SWIG_As_int(obj2));
13090 if (SWIG_arg_fail(3)) SWIG_fail;
13091 }
13092 {
13093 arg4 = (int)(SWIG_As_int(obj3));
13094 if (SWIG_arg_fail(4)) SWIG_fail;
13095 }
13096 {
13097 PyThreadState* __tstate = wxPyBeginAllowThreads();
13098 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13099
13100 wxPyEndAllowThreads(__tstate);
13101 if (PyErr_Occurred()) SWIG_fail;
13102 }
13103 Py_INCREF(Py_None); resultobj = Py_None;
13104 return resultobj;
13105 fail:
13106 return NULL;
13107 }
13108
13109
13110 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13111 PyObject *resultobj;
13112 wxImage *arg1 = (wxImage *) 0 ;
13113 PyObject *result;
13114 PyObject * obj0 = 0 ;
13115 char *kwnames[] = {
13116 (char *) "self", NULL
13117 };
13118
13119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13121 if (SWIG_arg_fail(1)) SWIG_fail;
13122 {
13123 PyThreadState* __tstate = wxPyBeginAllowThreads();
13124 result = (PyObject *)wxImage_GetData(arg1);
13125
13126 wxPyEndAllowThreads(__tstate);
13127 if (PyErr_Occurred()) SWIG_fail;
13128 }
13129 resultobj = result;
13130 return resultobj;
13131 fail:
13132 return NULL;
13133 }
13134
13135
13136 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13137 PyObject *resultobj;
13138 wxImage *arg1 = (wxImage *) 0 ;
13139 buffer arg2 ;
13140 int arg3 ;
13141 PyObject * obj0 = 0 ;
13142 PyObject * obj1 = 0 ;
13143 char *kwnames[] = {
13144 (char *) "self",(char *) "data", NULL
13145 };
13146
13147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13149 if (SWIG_arg_fail(1)) SWIG_fail;
13150 {
13151 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13152 }
13153 {
13154 PyThreadState* __tstate = wxPyBeginAllowThreads();
13155 wxImage_SetData(arg1,arg2,arg3);
13156
13157 wxPyEndAllowThreads(__tstate);
13158 if (PyErr_Occurred()) SWIG_fail;
13159 }
13160 Py_INCREF(Py_None); resultobj = Py_None;
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj;
13169 wxImage *arg1 = (wxImage *) 0 ;
13170 PyObject *result;
13171 PyObject * obj0 = 0 ;
13172 char *kwnames[] = {
13173 (char *) "self", NULL
13174 };
13175
13176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13178 if (SWIG_arg_fail(1)) SWIG_fail;
13179 {
13180 PyThreadState* __tstate = wxPyBeginAllowThreads();
13181 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13182
13183 wxPyEndAllowThreads(__tstate);
13184 if (PyErr_Occurred()) SWIG_fail;
13185 }
13186 resultobj = result;
13187 return resultobj;
13188 fail:
13189 return NULL;
13190 }
13191
13192
13193 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13194 PyObject *resultobj;
13195 wxImage *arg1 = (wxImage *) 0 ;
13196 buffer arg2 ;
13197 int arg3 ;
13198 PyObject * obj0 = 0 ;
13199 PyObject * obj1 = 0 ;
13200 char *kwnames[] = {
13201 (char *) "self",(char *) "data", NULL
13202 };
13203
13204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13206 if (SWIG_arg_fail(1)) SWIG_fail;
13207 {
13208 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13209 }
13210 {
13211 PyThreadState* __tstate = wxPyBeginAllowThreads();
13212 wxImage_SetDataBuffer(arg1,arg2,arg3);
13213
13214 wxPyEndAllowThreads(__tstate);
13215 if (PyErr_Occurred()) SWIG_fail;
13216 }
13217 Py_INCREF(Py_None); resultobj = Py_None;
13218 return resultobj;
13219 fail:
13220 return NULL;
13221 }
13222
13223
13224 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13225 PyObject *resultobj;
13226 wxImage *arg1 = (wxImage *) 0 ;
13227 PyObject *result;
13228 PyObject * obj0 = 0 ;
13229 char *kwnames[] = {
13230 (char *) "self", NULL
13231 };
13232
13233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13235 if (SWIG_arg_fail(1)) SWIG_fail;
13236 {
13237 PyThreadState* __tstate = wxPyBeginAllowThreads();
13238 result = (PyObject *)wxImage_GetAlphaData(arg1);
13239
13240 wxPyEndAllowThreads(__tstate);
13241 if (PyErr_Occurred()) SWIG_fail;
13242 }
13243 resultobj = result;
13244 return resultobj;
13245 fail:
13246 return NULL;
13247 }
13248
13249
13250 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13251 PyObject *resultobj;
13252 wxImage *arg1 = (wxImage *) 0 ;
13253 buffer arg2 ;
13254 int arg3 ;
13255 PyObject * obj0 = 0 ;
13256 PyObject * obj1 = 0 ;
13257 char *kwnames[] = {
13258 (char *) "self",(char *) "alpha", NULL
13259 };
13260
13261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13263 if (SWIG_arg_fail(1)) SWIG_fail;
13264 {
13265 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13266 }
13267 {
13268 PyThreadState* __tstate = wxPyBeginAllowThreads();
13269 wxImage_SetAlphaData(arg1,arg2,arg3);
13270
13271 wxPyEndAllowThreads(__tstate);
13272 if (PyErr_Occurred()) SWIG_fail;
13273 }
13274 Py_INCREF(Py_None); resultobj = Py_None;
13275 return resultobj;
13276 fail:
13277 return NULL;
13278 }
13279
13280
13281 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13282 PyObject *resultobj;
13283 wxImage *arg1 = (wxImage *) 0 ;
13284 PyObject *result;
13285 PyObject * obj0 = 0 ;
13286 char *kwnames[] = {
13287 (char *) "self", NULL
13288 };
13289
13290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13292 if (SWIG_arg_fail(1)) SWIG_fail;
13293 {
13294 PyThreadState* __tstate = wxPyBeginAllowThreads();
13295 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13296
13297 wxPyEndAllowThreads(__tstate);
13298 if (PyErr_Occurred()) SWIG_fail;
13299 }
13300 resultobj = result;
13301 return resultobj;
13302 fail:
13303 return NULL;
13304 }
13305
13306
13307 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13308 PyObject *resultobj;
13309 wxImage *arg1 = (wxImage *) 0 ;
13310 buffer arg2 ;
13311 int arg3 ;
13312 PyObject * obj0 = 0 ;
13313 PyObject * obj1 = 0 ;
13314 char *kwnames[] = {
13315 (char *) "self",(char *) "alpha", NULL
13316 };
13317
13318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13320 if (SWIG_arg_fail(1)) SWIG_fail;
13321 {
13322 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13323 }
13324 {
13325 PyThreadState* __tstate = wxPyBeginAllowThreads();
13326 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13327
13328 wxPyEndAllowThreads(__tstate);
13329 if (PyErr_Occurred()) SWIG_fail;
13330 }
13331 Py_INCREF(Py_None); resultobj = Py_None;
13332 return resultobj;
13333 fail:
13334 return NULL;
13335 }
13336
13337
13338 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13339 PyObject *resultobj;
13340 wxImage *arg1 = (wxImage *) 0 ;
13341 byte arg2 ;
13342 byte arg3 ;
13343 byte arg4 ;
13344 PyObject * obj0 = 0 ;
13345 PyObject * obj1 = 0 ;
13346 PyObject * obj2 = 0 ;
13347 PyObject * obj3 = 0 ;
13348 char *kwnames[] = {
13349 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13350 };
13351
13352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13354 if (SWIG_arg_fail(1)) SWIG_fail;
13355 {
13356 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13357 if (SWIG_arg_fail(2)) SWIG_fail;
13358 }
13359 {
13360 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13361 if (SWIG_arg_fail(3)) SWIG_fail;
13362 }
13363 {
13364 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13365 if (SWIG_arg_fail(4)) SWIG_fail;
13366 }
13367 {
13368 PyThreadState* __tstate = wxPyBeginAllowThreads();
13369 (arg1)->SetMaskColour(arg2,arg3,arg4);
13370
13371 wxPyEndAllowThreads(__tstate);
13372 if (PyErr_Occurred()) SWIG_fail;
13373 }
13374 Py_INCREF(Py_None); resultobj = Py_None;
13375 return resultobj;
13376 fail:
13377 return NULL;
13378 }
13379
13380
13381 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13382 PyObject *resultobj;
13383 wxImage *arg1 = (wxImage *) 0 ;
13384 byte *arg2 = (byte *) 0 ;
13385 byte *arg3 = (byte *) 0 ;
13386 byte *arg4 = (byte *) 0 ;
13387 byte temp2 ;
13388 int res2 = 0 ;
13389 byte temp3 ;
13390 int res3 = 0 ;
13391 byte temp4 ;
13392 int res4 = 0 ;
13393 PyObject * obj0 = 0 ;
13394 char *kwnames[] = {
13395 (char *) "self", NULL
13396 };
13397
13398 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13399 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13400 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13403 if (SWIG_arg_fail(1)) SWIG_fail;
13404 {
13405 PyThreadState* __tstate = wxPyBeginAllowThreads();
13406 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13407
13408 wxPyEndAllowThreads(__tstate);
13409 if (PyErr_Occurred()) SWIG_fail;
13410 }
13411 Py_INCREF(Py_None); resultobj = Py_None;
13412 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13413 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13414 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13415 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13416 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13417 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13418 return resultobj;
13419 fail:
13420 return NULL;
13421 }
13422
13423
13424 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13425 PyObject *resultobj;
13426 wxImage *arg1 = (wxImage *) 0 ;
13427 byte result;
13428 PyObject * obj0 = 0 ;
13429 char *kwnames[] = {
13430 (char *) "self", NULL
13431 };
13432
13433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13435 if (SWIG_arg_fail(1)) SWIG_fail;
13436 {
13437 PyThreadState* __tstate = wxPyBeginAllowThreads();
13438 result = (byte)(arg1)->GetMaskRed();
13439
13440 wxPyEndAllowThreads(__tstate);
13441 if (PyErr_Occurred()) SWIG_fail;
13442 }
13443 {
13444 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13445 }
13446 return resultobj;
13447 fail:
13448 return NULL;
13449 }
13450
13451
13452 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13453 PyObject *resultobj;
13454 wxImage *arg1 = (wxImage *) 0 ;
13455 byte result;
13456 PyObject * obj0 = 0 ;
13457 char *kwnames[] = {
13458 (char *) "self", NULL
13459 };
13460
13461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13463 if (SWIG_arg_fail(1)) SWIG_fail;
13464 {
13465 PyThreadState* __tstate = wxPyBeginAllowThreads();
13466 result = (byte)(arg1)->GetMaskGreen();
13467
13468 wxPyEndAllowThreads(__tstate);
13469 if (PyErr_Occurred()) SWIG_fail;
13470 }
13471 {
13472 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13473 }
13474 return resultobj;
13475 fail:
13476 return NULL;
13477 }
13478
13479
13480 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13481 PyObject *resultobj;
13482 wxImage *arg1 = (wxImage *) 0 ;
13483 byte result;
13484 PyObject * obj0 = 0 ;
13485 char *kwnames[] = {
13486 (char *) "self", NULL
13487 };
13488
13489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13491 if (SWIG_arg_fail(1)) SWIG_fail;
13492 {
13493 PyThreadState* __tstate = wxPyBeginAllowThreads();
13494 result = (byte)(arg1)->GetMaskBlue();
13495
13496 wxPyEndAllowThreads(__tstate);
13497 if (PyErr_Occurred()) SWIG_fail;
13498 }
13499 {
13500 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13501 }
13502 return resultobj;
13503 fail:
13504 return NULL;
13505 }
13506
13507
13508 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13509 PyObject *resultobj;
13510 wxImage *arg1 = (wxImage *) 0 ;
13511 bool arg2 = (bool) true ;
13512 PyObject * obj0 = 0 ;
13513 PyObject * obj1 = 0 ;
13514 char *kwnames[] = {
13515 (char *) "self",(char *) "mask", NULL
13516 };
13517
13518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13520 if (SWIG_arg_fail(1)) SWIG_fail;
13521 if (obj1) {
13522 {
13523 arg2 = (bool)(SWIG_As_bool(obj1));
13524 if (SWIG_arg_fail(2)) SWIG_fail;
13525 }
13526 }
13527 {
13528 PyThreadState* __tstate = wxPyBeginAllowThreads();
13529 (arg1)->SetMask(arg2);
13530
13531 wxPyEndAllowThreads(__tstate);
13532 if (PyErr_Occurred()) SWIG_fail;
13533 }
13534 Py_INCREF(Py_None); resultobj = Py_None;
13535 return resultobj;
13536 fail:
13537 return NULL;
13538 }
13539
13540
13541 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj;
13543 wxImage *arg1 = (wxImage *) 0 ;
13544 bool result;
13545 PyObject * obj0 = 0 ;
13546 char *kwnames[] = {
13547 (char *) "self", NULL
13548 };
13549
13550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13552 if (SWIG_arg_fail(1)) SWIG_fail;
13553 {
13554 PyThreadState* __tstate = wxPyBeginAllowThreads();
13555 result = (bool)(arg1)->HasMask();
13556
13557 wxPyEndAllowThreads(__tstate);
13558 if (PyErr_Occurred()) SWIG_fail;
13559 }
13560 {
13561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13562 }
13563 return resultobj;
13564 fail:
13565 return NULL;
13566 }
13567
13568
13569 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13570 PyObject *resultobj;
13571 wxImage *arg1 = (wxImage *) 0 ;
13572 double arg2 ;
13573 wxPoint *arg3 = 0 ;
13574 bool arg4 = (bool) true ;
13575 wxPoint *arg5 = (wxPoint *) NULL ;
13576 SwigValueWrapper<wxImage > result;
13577 wxPoint temp3 ;
13578 PyObject * obj0 = 0 ;
13579 PyObject * obj1 = 0 ;
13580 PyObject * obj2 = 0 ;
13581 PyObject * obj3 = 0 ;
13582 PyObject * obj4 = 0 ;
13583 char *kwnames[] = {
13584 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13585 };
13586
13587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13589 if (SWIG_arg_fail(1)) SWIG_fail;
13590 {
13591 arg2 = (double)(SWIG_As_double(obj1));
13592 if (SWIG_arg_fail(2)) SWIG_fail;
13593 }
13594 {
13595 arg3 = &temp3;
13596 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13597 }
13598 if (obj3) {
13599 {
13600 arg4 = (bool)(SWIG_As_bool(obj3));
13601 if (SWIG_arg_fail(4)) SWIG_fail;
13602 }
13603 }
13604 if (obj4) {
13605 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13606 if (SWIG_arg_fail(5)) SWIG_fail;
13607 }
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13611
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 {
13616 wxImage * resultptr;
13617 resultptr = new wxImage((wxImage &)(result));
13618 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13619 }
13620 return resultobj;
13621 fail:
13622 return NULL;
13623 }
13624
13625
13626 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13627 PyObject *resultobj;
13628 wxImage *arg1 = (wxImage *) 0 ;
13629 bool arg2 = (bool) true ;
13630 SwigValueWrapper<wxImage > result;
13631 PyObject * obj0 = 0 ;
13632 PyObject * obj1 = 0 ;
13633 char *kwnames[] = {
13634 (char *) "self",(char *) "clockwise", NULL
13635 };
13636
13637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13639 if (SWIG_arg_fail(1)) SWIG_fail;
13640 if (obj1) {
13641 {
13642 arg2 = (bool)(SWIG_As_bool(obj1));
13643 if (SWIG_arg_fail(2)) SWIG_fail;
13644 }
13645 }
13646 {
13647 PyThreadState* __tstate = wxPyBeginAllowThreads();
13648 result = (arg1)->Rotate90(arg2);
13649
13650 wxPyEndAllowThreads(__tstate);
13651 if (PyErr_Occurred()) SWIG_fail;
13652 }
13653 {
13654 wxImage * resultptr;
13655 resultptr = new wxImage((wxImage &)(result));
13656 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13657 }
13658 return resultobj;
13659 fail:
13660 return NULL;
13661 }
13662
13663
13664 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13665 PyObject *resultobj;
13666 wxImage *arg1 = (wxImage *) 0 ;
13667 bool arg2 = (bool) true ;
13668 SwigValueWrapper<wxImage > result;
13669 PyObject * obj0 = 0 ;
13670 PyObject * obj1 = 0 ;
13671 char *kwnames[] = {
13672 (char *) "self",(char *) "horizontally", NULL
13673 };
13674
13675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13677 if (SWIG_arg_fail(1)) SWIG_fail;
13678 if (obj1) {
13679 {
13680 arg2 = (bool)(SWIG_As_bool(obj1));
13681 if (SWIG_arg_fail(2)) SWIG_fail;
13682 }
13683 }
13684 {
13685 PyThreadState* __tstate = wxPyBeginAllowThreads();
13686 result = (arg1)->Mirror(arg2);
13687
13688 wxPyEndAllowThreads(__tstate);
13689 if (PyErr_Occurred()) SWIG_fail;
13690 }
13691 {
13692 wxImage * resultptr;
13693 resultptr = new wxImage((wxImage &)(result));
13694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13695 }
13696 return resultobj;
13697 fail:
13698 return NULL;
13699 }
13700
13701
13702 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13703 PyObject *resultobj;
13704 wxImage *arg1 = (wxImage *) 0 ;
13705 byte arg2 ;
13706 byte arg3 ;
13707 byte arg4 ;
13708 byte arg5 ;
13709 byte arg6 ;
13710 byte arg7 ;
13711 PyObject * obj0 = 0 ;
13712 PyObject * obj1 = 0 ;
13713 PyObject * obj2 = 0 ;
13714 PyObject * obj3 = 0 ;
13715 PyObject * obj4 = 0 ;
13716 PyObject * obj5 = 0 ;
13717 PyObject * obj6 = 0 ;
13718 char *kwnames[] = {
13719 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13720 };
13721
13722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13724 if (SWIG_arg_fail(1)) SWIG_fail;
13725 {
13726 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13727 if (SWIG_arg_fail(2)) SWIG_fail;
13728 }
13729 {
13730 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13731 if (SWIG_arg_fail(3)) SWIG_fail;
13732 }
13733 {
13734 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13735 if (SWIG_arg_fail(4)) SWIG_fail;
13736 }
13737 {
13738 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
13739 if (SWIG_arg_fail(5)) SWIG_fail;
13740 }
13741 {
13742 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
13743 if (SWIG_arg_fail(6)) SWIG_fail;
13744 }
13745 {
13746 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj6));
13747 if (SWIG_arg_fail(7)) SWIG_fail;
13748 }
13749 {
13750 PyThreadState* __tstate = wxPyBeginAllowThreads();
13751 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13752
13753 wxPyEndAllowThreads(__tstate);
13754 if (PyErr_Occurred()) SWIG_fail;
13755 }
13756 Py_INCREF(Py_None); resultobj = Py_None;
13757 return resultobj;
13758 fail:
13759 return NULL;
13760 }
13761
13762
13763 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13764 PyObject *resultobj;
13765 wxImage *arg1 = (wxImage *) 0 ;
13766 byte arg2 ;
13767 byte arg3 ;
13768 byte arg4 ;
13769 SwigValueWrapper<wxImage > result;
13770 PyObject * obj0 = 0 ;
13771 PyObject * obj1 = 0 ;
13772 PyObject * obj2 = 0 ;
13773 PyObject * obj3 = 0 ;
13774 char *kwnames[] = {
13775 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13776 };
13777
13778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13780 if (SWIG_arg_fail(1)) SWIG_fail;
13781 {
13782 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13783 if (SWIG_arg_fail(2)) SWIG_fail;
13784 }
13785 {
13786 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13787 if (SWIG_arg_fail(3)) SWIG_fail;
13788 }
13789 {
13790 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13791 if (SWIG_arg_fail(4)) SWIG_fail;
13792 }
13793 {
13794 PyThreadState* __tstate = wxPyBeginAllowThreads();
13795 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13796
13797 wxPyEndAllowThreads(__tstate);
13798 if (PyErr_Occurred()) SWIG_fail;
13799 }
13800 {
13801 wxImage * resultptr;
13802 resultptr = new wxImage((wxImage &)(result));
13803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13804 }
13805 return resultobj;
13806 fail:
13807 return NULL;
13808 }
13809
13810
13811 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13812 PyObject *resultobj;
13813 wxImage *arg1 = (wxImage *) 0 ;
13814 wxString *arg2 = 0 ;
13815 wxString *arg3 = 0 ;
13816 bool temp2 = false ;
13817 bool temp3 = false ;
13818 PyObject * obj0 = 0 ;
13819 PyObject * obj1 = 0 ;
13820 PyObject * obj2 = 0 ;
13821 char *kwnames[] = {
13822 (char *) "self",(char *) "name",(char *) "value", NULL
13823 };
13824
13825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13827 if (SWIG_arg_fail(1)) SWIG_fail;
13828 {
13829 arg2 = wxString_in_helper(obj1);
13830 if (arg2 == NULL) SWIG_fail;
13831 temp2 = true;
13832 }
13833 {
13834 arg3 = wxString_in_helper(obj2);
13835 if (arg3 == NULL) SWIG_fail;
13836 temp3 = true;
13837 }
13838 {
13839 PyThreadState* __tstate = wxPyBeginAllowThreads();
13840 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13841
13842 wxPyEndAllowThreads(__tstate);
13843 if (PyErr_Occurred()) SWIG_fail;
13844 }
13845 Py_INCREF(Py_None); resultobj = Py_None;
13846 {
13847 if (temp2)
13848 delete arg2;
13849 }
13850 {
13851 if (temp3)
13852 delete arg3;
13853 }
13854 return resultobj;
13855 fail:
13856 {
13857 if (temp2)
13858 delete arg2;
13859 }
13860 {
13861 if (temp3)
13862 delete arg3;
13863 }
13864 return NULL;
13865 }
13866
13867
13868 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13869 PyObject *resultobj;
13870 wxImage *arg1 = (wxImage *) 0 ;
13871 wxString *arg2 = 0 ;
13872 int arg3 ;
13873 bool temp2 = false ;
13874 PyObject * obj0 = 0 ;
13875 PyObject * obj1 = 0 ;
13876 PyObject * obj2 = 0 ;
13877 char *kwnames[] = {
13878 (char *) "self",(char *) "name",(char *) "value", NULL
13879 };
13880
13881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13883 if (SWIG_arg_fail(1)) SWIG_fail;
13884 {
13885 arg2 = wxString_in_helper(obj1);
13886 if (arg2 == NULL) SWIG_fail;
13887 temp2 = true;
13888 }
13889 {
13890 arg3 = (int)(SWIG_As_int(obj2));
13891 if (SWIG_arg_fail(3)) SWIG_fail;
13892 }
13893 {
13894 PyThreadState* __tstate = wxPyBeginAllowThreads();
13895 (arg1)->SetOption((wxString const &)*arg2,arg3);
13896
13897 wxPyEndAllowThreads(__tstate);
13898 if (PyErr_Occurred()) SWIG_fail;
13899 }
13900 Py_INCREF(Py_None); resultobj = Py_None;
13901 {
13902 if (temp2)
13903 delete arg2;
13904 }
13905 return resultobj;
13906 fail:
13907 {
13908 if (temp2)
13909 delete arg2;
13910 }
13911 return NULL;
13912 }
13913
13914
13915 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13916 PyObject *resultobj;
13917 wxImage *arg1 = (wxImage *) 0 ;
13918 wxString *arg2 = 0 ;
13919 wxString result;
13920 bool temp2 = false ;
13921 PyObject * obj0 = 0 ;
13922 PyObject * obj1 = 0 ;
13923 char *kwnames[] = {
13924 (char *) "self",(char *) "name", NULL
13925 };
13926
13927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13929 if (SWIG_arg_fail(1)) SWIG_fail;
13930 {
13931 arg2 = wxString_in_helper(obj1);
13932 if (arg2 == NULL) SWIG_fail;
13933 temp2 = true;
13934 }
13935 {
13936 PyThreadState* __tstate = wxPyBeginAllowThreads();
13937 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13938
13939 wxPyEndAllowThreads(__tstate);
13940 if (PyErr_Occurred()) SWIG_fail;
13941 }
13942 {
13943 #if wxUSE_UNICODE
13944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13945 #else
13946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13947 #endif
13948 }
13949 {
13950 if (temp2)
13951 delete arg2;
13952 }
13953 return resultobj;
13954 fail:
13955 {
13956 if (temp2)
13957 delete arg2;
13958 }
13959 return NULL;
13960 }
13961
13962
13963 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13964 PyObject *resultobj;
13965 wxImage *arg1 = (wxImage *) 0 ;
13966 wxString *arg2 = 0 ;
13967 int result;
13968 bool temp2 = false ;
13969 PyObject * obj0 = 0 ;
13970 PyObject * obj1 = 0 ;
13971 char *kwnames[] = {
13972 (char *) "self",(char *) "name", NULL
13973 };
13974
13975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13977 if (SWIG_arg_fail(1)) SWIG_fail;
13978 {
13979 arg2 = wxString_in_helper(obj1);
13980 if (arg2 == NULL) SWIG_fail;
13981 temp2 = true;
13982 }
13983 {
13984 PyThreadState* __tstate = wxPyBeginAllowThreads();
13985 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13986
13987 wxPyEndAllowThreads(__tstate);
13988 if (PyErr_Occurred()) SWIG_fail;
13989 }
13990 {
13991 resultobj = SWIG_From_int((int)(result));
13992 }
13993 {
13994 if (temp2)
13995 delete arg2;
13996 }
13997 return resultobj;
13998 fail:
13999 {
14000 if (temp2)
14001 delete arg2;
14002 }
14003 return NULL;
14004 }
14005
14006
14007 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
14008 PyObject *resultobj;
14009 wxImage *arg1 = (wxImage *) 0 ;
14010 wxString *arg2 = 0 ;
14011 bool result;
14012 bool temp2 = false ;
14013 PyObject * obj0 = 0 ;
14014 PyObject * obj1 = 0 ;
14015 char *kwnames[] = {
14016 (char *) "self",(char *) "name", NULL
14017 };
14018
14019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
14020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14021 if (SWIG_arg_fail(1)) SWIG_fail;
14022 {
14023 arg2 = wxString_in_helper(obj1);
14024 if (arg2 == NULL) SWIG_fail;
14025 temp2 = true;
14026 }
14027 {
14028 PyThreadState* __tstate = wxPyBeginAllowThreads();
14029 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14030
14031 wxPyEndAllowThreads(__tstate);
14032 if (PyErr_Occurred()) SWIG_fail;
14033 }
14034 {
14035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14036 }
14037 {
14038 if (temp2)
14039 delete arg2;
14040 }
14041 return resultobj;
14042 fail:
14043 {
14044 if (temp2)
14045 delete arg2;
14046 }
14047 return NULL;
14048 }
14049
14050
14051 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14052 PyObject *resultobj;
14053 wxImage *arg1 = (wxImage *) 0 ;
14054 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14055 unsigned long result;
14056 PyObject * obj0 = 0 ;
14057 PyObject * obj1 = 0 ;
14058 char *kwnames[] = {
14059 (char *) "self",(char *) "stopafter", NULL
14060 };
14061
14062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14064 if (SWIG_arg_fail(1)) SWIG_fail;
14065 if (obj1) {
14066 {
14067 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
14068 if (SWIG_arg_fail(2)) SWIG_fail;
14069 }
14070 }
14071 {
14072 PyThreadState* __tstate = wxPyBeginAllowThreads();
14073 result = (unsigned long)(arg1)->CountColours(arg2);
14074
14075 wxPyEndAllowThreads(__tstate);
14076 if (PyErr_Occurred()) SWIG_fail;
14077 }
14078 {
14079 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
14080 }
14081 return resultobj;
14082 fail:
14083 return NULL;
14084 }
14085
14086
14087 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14088 PyObject *resultobj;
14089 wxImage *arg1 = (wxImage *) 0 ;
14090 wxImageHistogram *arg2 = 0 ;
14091 unsigned long result;
14092 PyObject * obj0 = 0 ;
14093 PyObject * obj1 = 0 ;
14094 char *kwnames[] = {
14095 (char *) "self",(char *) "h", NULL
14096 };
14097
14098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14100 if (SWIG_arg_fail(1)) SWIG_fail;
14101 {
14102 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14103 if (SWIG_arg_fail(2)) SWIG_fail;
14104 if (arg2 == NULL) {
14105 SWIG_null_ref("wxImageHistogram");
14106 }
14107 if (SWIG_arg_fail(2)) SWIG_fail;
14108 }
14109 {
14110 PyThreadState* __tstate = wxPyBeginAllowThreads();
14111 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14112
14113 wxPyEndAllowThreads(__tstate);
14114 if (PyErr_Occurred()) SWIG_fail;
14115 }
14116 {
14117 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
14118 }
14119 return resultobj;
14120 fail:
14121 return NULL;
14122 }
14123
14124
14125 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14126 PyObject *resultobj;
14127 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14128 PyObject * obj0 = 0 ;
14129 char *kwnames[] = {
14130 (char *) "handler", NULL
14131 };
14132
14133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14135 if (SWIG_arg_fail(1)) SWIG_fail;
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 wxImage::AddHandler(arg1);
14139
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 Py_INCREF(Py_None); resultobj = Py_None;
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj;
14152 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14153 PyObject * obj0 = 0 ;
14154 char *kwnames[] = {
14155 (char *) "handler", NULL
14156 };
14157
14158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14160 if (SWIG_arg_fail(1)) SWIG_fail;
14161 {
14162 PyThreadState* __tstate = wxPyBeginAllowThreads();
14163 wxImage::InsertHandler(arg1);
14164
14165 wxPyEndAllowThreads(__tstate);
14166 if (PyErr_Occurred()) SWIG_fail;
14167 }
14168 Py_INCREF(Py_None); resultobj = Py_None;
14169 return resultobj;
14170 fail:
14171 return NULL;
14172 }
14173
14174
14175 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14176 PyObject *resultobj;
14177 wxString *arg1 = 0 ;
14178 bool result;
14179 bool temp1 = false ;
14180 PyObject * obj0 = 0 ;
14181 char *kwnames[] = {
14182 (char *) "name", NULL
14183 };
14184
14185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14186 {
14187 arg1 = wxString_in_helper(obj0);
14188 if (arg1 == NULL) SWIG_fail;
14189 temp1 = true;
14190 }
14191 {
14192 PyThreadState* __tstate = wxPyBeginAllowThreads();
14193 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14194
14195 wxPyEndAllowThreads(__tstate);
14196 if (PyErr_Occurred()) SWIG_fail;
14197 }
14198 {
14199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14200 }
14201 {
14202 if (temp1)
14203 delete arg1;
14204 }
14205 return resultobj;
14206 fail:
14207 {
14208 if (temp1)
14209 delete arg1;
14210 }
14211 return NULL;
14212 }
14213
14214
14215 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14216 PyObject *resultobj;
14217 wxString result;
14218 char *kwnames[] = {
14219 NULL
14220 };
14221
14222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14223 {
14224 PyThreadState* __tstate = wxPyBeginAllowThreads();
14225 result = wxImage::GetImageExtWildcard();
14226
14227 wxPyEndAllowThreads(__tstate);
14228 if (PyErr_Occurred()) SWIG_fail;
14229 }
14230 {
14231 #if wxUSE_UNICODE
14232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14233 #else
14234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14235 #endif
14236 }
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj;
14245 wxImage *arg1 = (wxImage *) 0 ;
14246 int arg2 = (int) -1 ;
14247 wxBitmap result;
14248 PyObject * obj0 = 0 ;
14249 PyObject * obj1 = 0 ;
14250 char *kwnames[] = {
14251 (char *) "self",(char *) "depth", NULL
14252 };
14253
14254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14256 if (SWIG_arg_fail(1)) SWIG_fail;
14257 if (obj1) {
14258 {
14259 arg2 = (int)(SWIG_As_int(obj1));
14260 if (SWIG_arg_fail(2)) SWIG_fail;
14261 }
14262 }
14263 {
14264 if (!wxPyCheckForApp()) SWIG_fail;
14265 PyThreadState* __tstate = wxPyBeginAllowThreads();
14266 result = wxImage_ConvertToBitmap(arg1,arg2);
14267
14268 wxPyEndAllowThreads(__tstate);
14269 if (PyErr_Occurred()) SWIG_fail;
14270 }
14271 {
14272 wxBitmap * resultptr;
14273 resultptr = new wxBitmap((wxBitmap &)(result));
14274 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14275 }
14276 return resultobj;
14277 fail:
14278 return NULL;
14279 }
14280
14281
14282 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14283 PyObject *resultobj;
14284 wxImage *arg1 = (wxImage *) 0 ;
14285 byte arg2 ;
14286 byte arg3 ;
14287 byte arg4 ;
14288 wxBitmap result;
14289 PyObject * obj0 = 0 ;
14290 PyObject * obj1 = 0 ;
14291 PyObject * obj2 = 0 ;
14292 PyObject * obj3 = 0 ;
14293 char *kwnames[] = {
14294 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14295 };
14296
14297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14299 if (SWIG_arg_fail(1)) SWIG_fail;
14300 {
14301 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
14302 if (SWIG_arg_fail(2)) SWIG_fail;
14303 }
14304 {
14305 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
14306 if (SWIG_arg_fail(3)) SWIG_fail;
14307 }
14308 {
14309 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
14310 if (SWIG_arg_fail(4)) SWIG_fail;
14311 }
14312 {
14313 if (!wxPyCheckForApp()) SWIG_fail;
14314 PyThreadState* __tstate = wxPyBeginAllowThreads();
14315 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14316
14317 wxPyEndAllowThreads(__tstate);
14318 if (PyErr_Occurred()) SWIG_fail;
14319 }
14320 {
14321 wxBitmap * resultptr;
14322 resultptr = new wxBitmap((wxBitmap &)(result));
14323 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14324 }
14325 return resultobj;
14326 fail:
14327 return NULL;
14328 }
14329
14330
14331 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14332 PyObject *resultobj;
14333 wxImage *arg1 = (wxImage *) 0 ;
14334 double arg2 ;
14335 PyObject * obj0 = 0 ;
14336 PyObject * obj1 = 0 ;
14337 char *kwnames[] = {
14338 (char *) "self",(char *) "angle", NULL
14339 };
14340
14341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14343 if (SWIG_arg_fail(1)) SWIG_fail;
14344 {
14345 arg2 = (double)(SWIG_As_double(obj1));
14346 if (SWIG_arg_fail(2)) SWIG_fail;
14347 }
14348 {
14349 PyThreadState* __tstate = wxPyBeginAllowThreads();
14350 (arg1)->RotateHue(arg2);
14351
14352 wxPyEndAllowThreads(__tstate);
14353 if (PyErr_Occurred()) SWIG_fail;
14354 }
14355 Py_INCREF(Py_None); resultobj = Py_None;
14356 return resultobj;
14357 fail:
14358 return NULL;
14359 }
14360
14361
14362 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14363 PyObject *resultobj;
14364 wxImage_RGBValue arg1 ;
14365 wxImage_HSVValue result;
14366 PyObject * obj0 = 0 ;
14367 char *kwnames[] = {
14368 (char *) "rgb", NULL
14369 };
14370
14371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14372 {
14373 wxImage_RGBValue * argp;
14374 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14375 if (SWIG_arg_fail(1)) SWIG_fail;
14376 if (argp == NULL) {
14377 SWIG_null_ref("wxImage_RGBValue");
14378 }
14379 if (SWIG_arg_fail(1)) SWIG_fail;
14380 arg1 = *argp;
14381 }
14382 {
14383 PyThreadState* __tstate = wxPyBeginAllowThreads();
14384 result = wxImage::RGBtoHSV(arg1);
14385
14386 wxPyEndAllowThreads(__tstate);
14387 if (PyErr_Occurred()) SWIG_fail;
14388 }
14389 {
14390 wxImage_HSVValue * resultptr;
14391 resultptr = new wxImage_HSVValue((wxImage_HSVValue &)(result));
14392 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14393 }
14394 return resultobj;
14395 fail:
14396 return NULL;
14397 }
14398
14399
14400 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14401 PyObject *resultobj;
14402 wxImage_HSVValue arg1 ;
14403 wxImage_RGBValue result;
14404 PyObject * obj0 = 0 ;
14405 char *kwnames[] = {
14406 (char *) "hsv", NULL
14407 };
14408
14409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14410 {
14411 wxImage_HSVValue * argp;
14412 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14413 if (SWIG_arg_fail(1)) SWIG_fail;
14414 if (argp == NULL) {
14415 SWIG_null_ref("wxImage_HSVValue");
14416 }
14417 if (SWIG_arg_fail(1)) SWIG_fail;
14418 arg1 = *argp;
14419 }
14420 {
14421 PyThreadState* __tstate = wxPyBeginAllowThreads();
14422 result = wxImage::HSVtoRGB(arg1);
14423
14424 wxPyEndAllowThreads(__tstate);
14425 if (PyErr_Occurred()) SWIG_fail;
14426 }
14427 {
14428 wxImage_RGBValue * resultptr;
14429 resultptr = new wxImage_RGBValue((wxImage_RGBValue &)(result));
14430 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14431 }
14432 return resultobj;
14433 fail:
14434 return NULL;
14435 }
14436
14437
14438 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14439 PyObject *obj;
14440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14441 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14442 Py_INCREF(obj);
14443 return Py_BuildValue((char *)"");
14444 }
14445 static int _wrap_NullImage_set(PyObject *) {
14446 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14447 return 1;
14448 }
14449
14450
14451 static PyObject *_wrap_NullImage_get(void) {
14452 PyObject *pyobj;
14453
14454 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14455 return pyobj;
14456 }
14457
14458
14459 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14460 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14461 return 1;
14462 }
14463
14464
14465 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14466 PyObject *pyobj;
14467
14468 {
14469 #if wxUSE_UNICODE
14470 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14471 #else
14472 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14473 #endif
14474 }
14475 return pyobj;
14476 }
14477
14478
14479 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14480 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14481 return 1;
14482 }
14483
14484
14485 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14486 PyObject *pyobj;
14487
14488 {
14489 #if wxUSE_UNICODE
14490 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14491 #else
14492 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14493 #endif
14494 }
14495 return pyobj;
14496 }
14497
14498
14499 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14500 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14501 return 1;
14502 }
14503
14504
14505 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14506 PyObject *pyobj;
14507
14508 {
14509 #if wxUSE_UNICODE
14510 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14511 #else
14512 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14513 #endif
14514 }
14515 return pyobj;
14516 }
14517
14518
14519 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14520 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14521 return 1;
14522 }
14523
14524
14525 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14526 PyObject *pyobj;
14527
14528 {
14529 #if wxUSE_UNICODE
14530 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14531 #else
14532 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14533 #endif
14534 }
14535 return pyobj;
14536 }
14537
14538
14539 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14540 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14541 return 1;
14542 }
14543
14544
14545 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14546 PyObject *pyobj;
14547
14548 {
14549 #if wxUSE_UNICODE
14550 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14551 #else
14552 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14553 #endif
14554 }
14555 return pyobj;
14556 }
14557
14558
14559 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14560 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14561 return 1;
14562 }
14563
14564
14565 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14566 PyObject *pyobj;
14567
14568 {
14569 #if wxUSE_UNICODE
14570 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14571 #else
14572 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14573 #endif
14574 }
14575 return pyobj;
14576 }
14577
14578
14579 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14580 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14581 return 1;
14582 }
14583
14584
14585 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14586 PyObject *pyobj;
14587
14588 {
14589 #if wxUSE_UNICODE
14590 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14591 #else
14592 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14593 #endif
14594 }
14595 return pyobj;
14596 }
14597
14598
14599 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14600 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14601 return 1;
14602 }
14603
14604
14605 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14606 PyObject *pyobj;
14607
14608 {
14609 #if wxUSE_UNICODE
14610 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14611 #else
14612 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14613 #endif
14614 }
14615 return pyobj;
14616 }
14617
14618
14619 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14620 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14621 return 1;
14622 }
14623
14624
14625 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14626 PyObject *pyobj;
14627
14628 {
14629 #if wxUSE_UNICODE
14630 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14631 #else
14632 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14633 #endif
14634 }
14635 return pyobj;
14636 }
14637
14638
14639 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14640 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14641 return 1;
14642 }
14643
14644
14645 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14646 PyObject *pyobj;
14647
14648 {
14649 #if wxUSE_UNICODE
14650 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14651 #else
14652 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14653 #endif
14654 }
14655 return pyobj;
14656 }
14657
14658
14659 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14660 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14661 return 1;
14662 }
14663
14664
14665 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14666 PyObject *pyobj;
14667
14668 {
14669 #if wxUSE_UNICODE
14670 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14671 #else
14672 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14673 #endif
14674 }
14675 return pyobj;
14676 }
14677
14678
14679 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14680 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14681 return 1;
14682 }
14683
14684
14685 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14686 PyObject *pyobj;
14687
14688 {
14689 #if wxUSE_UNICODE
14690 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14691 #else
14692 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14693 #endif
14694 }
14695 return pyobj;
14696 }
14697
14698
14699 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14700 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14701 return 1;
14702 }
14703
14704
14705 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14706 PyObject *pyobj;
14707
14708 {
14709 #if wxUSE_UNICODE
14710 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14711 #else
14712 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14713 #endif
14714 }
14715 return pyobj;
14716 }
14717
14718
14719 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14720 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14721 return 1;
14722 }
14723
14724
14725 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14726 PyObject *pyobj;
14727
14728 {
14729 #if wxUSE_UNICODE
14730 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14731 #else
14732 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14733 #endif
14734 }
14735 return pyobj;
14736 }
14737
14738
14739 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14740 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14741 return 1;
14742 }
14743
14744
14745 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14746 PyObject *pyobj;
14747
14748 {
14749 #if wxUSE_UNICODE
14750 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14751 #else
14752 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14753 #endif
14754 }
14755 return pyobj;
14756 }
14757
14758
14759 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14760 PyObject *resultobj;
14761 wxBMPHandler *result;
14762 char *kwnames[] = {
14763 NULL
14764 };
14765
14766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14767 {
14768 PyThreadState* __tstate = wxPyBeginAllowThreads();
14769 result = (wxBMPHandler *)new wxBMPHandler();
14770
14771 wxPyEndAllowThreads(__tstate);
14772 if (PyErr_Occurred()) SWIG_fail;
14773 }
14774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14775 return resultobj;
14776 fail:
14777 return NULL;
14778 }
14779
14780
14781 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14782 PyObject *obj;
14783 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14784 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14785 Py_INCREF(obj);
14786 return Py_BuildValue((char *)"");
14787 }
14788 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14789 PyObject *resultobj;
14790 wxICOHandler *result;
14791 char *kwnames[] = {
14792 NULL
14793 };
14794
14795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14796 {
14797 PyThreadState* __tstate = wxPyBeginAllowThreads();
14798 result = (wxICOHandler *)new wxICOHandler();
14799
14800 wxPyEndAllowThreads(__tstate);
14801 if (PyErr_Occurred()) SWIG_fail;
14802 }
14803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14804 return resultobj;
14805 fail:
14806 return NULL;
14807 }
14808
14809
14810 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14811 PyObject *obj;
14812 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14813 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14814 Py_INCREF(obj);
14815 return Py_BuildValue((char *)"");
14816 }
14817 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14818 PyObject *resultobj;
14819 wxCURHandler *result;
14820 char *kwnames[] = {
14821 NULL
14822 };
14823
14824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14825 {
14826 PyThreadState* __tstate = wxPyBeginAllowThreads();
14827 result = (wxCURHandler *)new wxCURHandler();
14828
14829 wxPyEndAllowThreads(__tstate);
14830 if (PyErr_Occurred()) SWIG_fail;
14831 }
14832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14833 return resultobj;
14834 fail:
14835 return NULL;
14836 }
14837
14838
14839 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14840 PyObject *obj;
14841 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14842 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14843 Py_INCREF(obj);
14844 return Py_BuildValue((char *)"");
14845 }
14846 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14847 PyObject *resultobj;
14848 wxANIHandler *result;
14849 char *kwnames[] = {
14850 NULL
14851 };
14852
14853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14854 {
14855 PyThreadState* __tstate = wxPyBeginAllowThreads();
14856 result = (wxANIHandler *)new wxANIHandler();
14857
14858 wxPyEndAllowThreads(__tstate);
14859 if (PyErr_Occurred()) SWIG_fail;
14860 }
14861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14862 return resultobj;
14863 fail:
14864 return NULL;
14865 }
14866
14867
14868 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14869 PyObject *obj;
14870 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14871 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14872 Py_INCREF(obj);
14873 return Py_BuildValue((char *)"");
14874 }
14875 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14876 PyObject *resultobj;
14877 wxPNGHandler *result;
14878 char *kwnames[] = {
14879 NULL
14880 };
14881
14882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14883 {
14884 PyThreadState* __tstate = wxPyBeginAllowThreads();
14885 result = (wxPNGHandler *)new wxPNGHandler();
14886
14887 wxPyEndAllowThreads(__tstate);
14888 if (PyErr_Occurred()) SWIG_fail;
14889 }
14890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14891 return resultobj;
14892 fail:
14893 return NULL;
14894 }
14895
14896
14897 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14898 PyObject *obj;
14899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14900 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14901 Py_INCREF(obj);
14902 return Py_BuildValue((char *)"");
14903 }
14904 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14905 PyObject *resultobj;
14906 wxGIFHandler *result;
14907 char *kwnames[] = {
14908 NULL
14909 };
14910
14911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14912 {
14913 PyThreadState* __tstate = wxPyBeginAllowThreads();
14914 result = (wxGIFHandler *)new wxGIFHandler();
14915
14916 wxPyEndAllowThreads(__tstate);
14917 if (PyErr_Occurred()) SWIG_fail;
14918 }
14919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14920 return resultobj;
14921 fail:
14922 return NULL;
14923 }
14924
14925
14926 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14927 PyObject *obj;
14928 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14929 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14930 Py_INCREF(obj);
14931 return Py_BuildValue((char *)"");
14932 }
14933 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14934 PyObject *resultobj;
14935 wxPCXHandler *result;
14936 char *kwnames[] = {
14937 NULL
14938 };
14939
14940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14941 {
14942 PyThreadState* __tstate = wxPyBeginAllowThreads();
14943 result = (wxPCXHandler *)new wxPCXHandler();
14944
14945 wxPyEndAllowThreads(__tstate);
14946 if (PyErr_Occurred()) SWIG_fail;
14947 }
14948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14949 return resultobj;
14950 fail:
14951 return NULL;
14952 }
14953
14954
14955 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14956 PyObject *obj;
14957 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14958 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14959 Py_INCREF(obj);
14960 return Py_BuildValue((char *)"");
14961 }
14962 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14963 PyObject *resultobj;
14964 wxJPEGHandler *result;
14965 char *kwnames[] = {
14966 NULL
14967 };
14968
14969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14970 {
14971 PyThreadState* __tstate = wxPyBeginAllowThreads();
14972 result = (wxJPEGHandler *)new wxJPEGHandler();
14973
14974 wxPyEndAllowThreads(__tstate);
14975 if (PyErr_Occurred()) SWIG_fail;
14976 }
14977 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14978 return resultobj;
14979 fail:
14980 return NULL;
14981 }
14982
14983
14984 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14985 PyObject *obj;
14986 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14987 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14988 Py_INCREF(obj);
14989 return Py_BuildValue((char *)"");
14990 }
14991 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14992 PyObject *resultobj;
14993 wxPNMHandler *result;
14994 char *kwnames[] = {
14995 NULL
14996 };
14997
14998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14999 {
15000 PyThreadState* __tstate = wxPyBeginAllowThreads();
15001 result = (wxPNMHandler *)new wxPNMHandler();
15002
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
15007 return resultobj;
15008 fail:
15009 return NULL;
15010 }
15011
15012
15013 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
15014 PyObject *obj;
15015 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15016 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
15017 Py_INCREF(obj);
15018 return Py_BuildValue((char *)"");
15019 }
15020 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15021 PyObject *resultobj;
15022 wxXPMHandler *result;
15023 char *kwnames[] = {
15024 NULL
15025 };
15026
15027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15028 {
15029 PyThreadState* __tstate = wxPyBeginAllowThreads();
15030 result = (wxXPMHandler *)new wxXPMHandler();
15031
15032 wxPyEndAllowThreads(__tstate);
15033 if (PyErr_Occurred()) SWIG_fail;
15034 }
15035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15036 return resultobj;
15037 fail:
15038 return NULL;
15039 }
15040
15041
15042 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15043 PyObject *obj;
15044 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15045 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15046 Py_INCREF(obj);
15047 return Py_BuildValue((char *)"");
15048 }
15049 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15050 PyObject *resultobj;
15051 wxTIFFHandler *result;
15052 char *kwnames[] = {
15053 NULL
15054 };
15055
15056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15057 {
15058 PyThreadState* __tstate = wxPyBeginAllowThreads();
15059 result = (wxTIFFHandler *)new wxTIFFHandler();
15060
15061 wxPyEndAllowThreads(__tstate);
15062 if (PyErr_Occurred()) SWIG_fail;
15063 }
15064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15065 return resultobj;
15066 fail:
15067 return NULL;
15068 }
15069
15070
15071 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15072 PyObject *obj;
15073 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15074 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15075 Py_INCREF(obj);
15076 return Py_BuildValue((char *)"");
15077 }
15078 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15079 PyObject *resultobj;
15080 wxImage *arg1 = 0 ;
15081 wxImage *arg2 = 0 ;
15082 int arg3 = (int) 236 ;
15083 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15084 bool result;
15085 PyObject * obj0 = 0 ;
15086 PyObject * obj1 = 0 ;
15087 PyObject * obj2 = 0 ;
15088 PyObject * obj3 = 0 ;
15089 char *kwnames[] = {
15090 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15091 };
15092
15093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15094 {
15095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15096 if (SWIG_arg_fail(1)) SWIG_fail;
15097 if (arg1 == NULL) {
15098 SWIG_null_ref("wxImage");
15099 }
15100 if (SWIG_arg_fail(1)) SWIG_fail;
15101 }
15102 {
15103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15104 if (SWIG_arg_fail(2)) SWIG_fail;
15105 if (arg2 == NULL) {
15106 SWIG_null_ref("wxImage");
15107 }
15108 if (SWIG_arg_fail(2)) SWIG_fail;
15109 }
15110 if (obj2) {
15111 {
15112 arg3 = (int)(SWIG_As_int(obj2));
15113 if (SWIG_arg_fail(3)) SWIG_fail;
15114 }
15115 }
15116 if (obj3) {
15117 {
15118 arg4 = (int)(SWIG_As_int(obj3));
15119 if (SWIG_arg_fail(4)) SWIG_fail;
15120 }
15121 }
15122 {
15123 PyThreadState* __tstate = wxPyBeginAllowThreads();
15124 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15125
15126 wxPyEndAllowThreads(__tstate);
15127 if (PyErr_Occurred()) SWIG_fail;
15128 }
15129 {
15130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15131 }
15132 return resultobj;
15133 fail:
15134 return NULL;
15135 }
15136
15137
15138 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15139 PyObject *obj;
15140 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15141 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15142 Py_INCREF(obj);
15143 return Py_BuildValue((char *)"");
15144 }
15145 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15146 PyObject *resultobj;
15147 wxEvtHandler *result;
15148 char *kwnames[] = {
15149 NULL
15150 };
15151
15152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15153 {
15154 PyThreadState* __tstate = wxPyBeginAllowThreads();
15155 result = (wxEvtHandler *)new wxEvtHandler();
15156
15157 wxPyEndAllowThreads(__tstate);
15158 if (PyErr_Occurred()) SWIG_fail;
15159 }
15160 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15161 return resultobj;
15162 fail:
15163 return NULL;
15164 }
15165
15166
15167 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15168 PyObject *resultobj;
15169 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15170 wxEvtHandler *result;
15171 PyObject * obj0 = 0 ;
15172 char *kwnames[] = {
15173 (char *) "self", NULL
15174 };
15175
15176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15178 if (SWIG_arg_fail(1)) SWIG_fail;
15179 {
15180 PyThreadState* __tstate = wxPyBeginAllowThreads();
15181 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15182
15183 wxPyEndAllowThreads(__tstate);
15184 if (PyErr_Occurred()) SWIG_fail;
15185 }
15186 {
15187 resultobj = wxPyMake_wxObject(result, 0);
15188 }
15189 return resultobj;
15190 fail:
15191 return NULL;
15192 }
15193
15194
15195 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15196 PyObject *resultobj;
15197 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15198 wxEvtHandler *result;
15199 PyObject * obj0 = 0 ;
15200 char *kwnames[] = {
15201 (char *) "self", NULL
15202 };
15203
15204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15206 if (SWIG_arg_fail(1)) SWIG_fail;
15207 {
15208 PyThreadState* __tstate = wxPyBeginAllowThreads();
15209 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15210
15211 wxPyEndAllowThreads(__tstate);
15212 if (PyErr_Occurred()) SWIG_fail;
15213 }
15214 {
15215 resultobj = wxPyMake_wxObject(result, 0);
15216 }
15217 return resultobj;
15218 fail:
15219 return NULL;
15220 }
15221
15222
15223 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15224 PyObject *resultobj;
15225 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15226 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15227 PyObject * obj0 = 0 ;
15228 PyObject * obj1 = 0 ;
15229 char *kwnames[] = {
15230 (char *) "self",(char *) "handler", NULL
15231 };
15232
15233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15235 if (SWIG_arg_fail(1)) SWIG_fail;
15236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15237 if (SWIG_arg_fail(2)) SWIG_fail;
15238 {
15239 PyThreadState* __tstate = wxPyBeginAllowThreads();
15240 (arg1)->SetNextHandler(arg2);
15241
15242 wxPyEndAllowThreads(__tstate);
15243 if (PyErr_Occurred()) SWIG_fail;
15244 }
15245 Py_INCREF(Py_None); resultobj = Py_None;
15246 return resultobj;
15247 fail:
15248 return NULL;
15249 }
15250
15251
15252 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15253 PyObject *resultobj;
15254 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15255 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15256 PyObject * obj0 = 0 ;
15257 PyObject * obj1 = 0 ;
15258 char *kwnames[] = {
15259 (char *) "self",(char *) "handler", NULL
15260 };
15261
15262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15264 if (SWIG_arg_fail(1)) SWIG_fail;
15265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15266 if (SWIG_arg_fail(2)) SWIG_fail;
15267 {
15268 PyThreadState* __tstate = wxPyBeginAllowThreads();
15269 (arg1)->SetPreviousHandler(arg2);
15270
15271 wxPyEndAllowThreads(__tstate);
15272 if (PyErr_Occurred()) SWIG_fail;
15273 }
15274 Py_INCREF(Py_None); resultobj = Py_None;
15275 return resultobj;
15276 fail:
15277 return NULL;
15278 }
15279
15280
15281 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15282 PyObject *resultobj;
15283 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15284 bool result;
15285 PyObject * obj0 = 0 ;
15286 char *kwnames[] = {
15287 (char *) "self", NULL
15288 };
15289
15290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15292 if (SWIG_arg_fail(1)) SWIG_fail;
15293 {
15294 PyThreadState* __tstate = wxPyBeginAllowThreads();
15295 result = (bool)(arg1)->GetEvtHandlerEnabled();
15296
15297 wxPyEndAllowThreads(__tstate);
15298 if (PyErr_Occurred()) SWIG_fail;
15299 }
15300 {
15301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15302 }
15303 return resultobj;
15304 fail:
15305 return NULL;
15306 }
15307
15308
15309 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15310 PyObject *resultobj;
15311 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15312 bool arg2 ;
15313 PyObject * obj0 = 0 ;
15314 PyObject * obj1 = 0 ;
15315 char *kwnames[] = {
15316 (char *) "self",(char *) "enabled", NULL
15317 };
15318
15319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15321 if (SWIG_arg_fail(1)) SWIG_fail;
15322 {
15323 arg2 = (bool)(SWIG_As_bool(obj1));
15324 if (SWIG_arg_fail(2)) SWIG_fail;
15325 }
15326 {
15327 PyThreadState* __tstate = wxPyBeginAllowThreads();
15328 (arg1)->SetEvtHandlerEnabled(arg2);
15329
15330 wxPyEndAllowThreads(__tstate);
15331 if (PyErr_Occurred()) SWIG_fail;
15332 }
15333 Py_INCREF(Py_None); resultobj = Py_None;
15334 return resultobj;
15335 fail:
15336 return NULL;
15337 }
15338
15339
15340 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15341 PyObject *resultobj;
15342 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15343 wxEvent *arg2 = 0 ;
15344 bool result;
15345 PyObject * obj0 = 0 ;
15346 PyObject * obj1 = 0 ;
15347 char *kwnames[] = {
15348 (char *) "self",(char *) "event", NULL
15349 };
15350
15351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15353 if (SWIG_arg_fail(1)) SWIG_fail;
15354 {
15355 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15356 if (SWIG_arg_fail(2)) SWIG_fail;
15357 if (arg2 == NULL) {
15358 SWIG_null_ref("wxEvent");
15359 }
15360 if (SWIG_arg_fail(2)) SWIG_fail;
15361 }
15362 {
15363 PyThreadState* __tstate = wxPyBeginAllowThreads();
15364 result = (bool)(arg1)->ProcessEvent(*arg2);
15365
15366 wxPyEndAllowThreads(__tstate);
15367 if (PyErr_Occurred()) SWIG_fail;
15368 }
15369 {
15370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15371 }
15372 return resultobj;
15373 fail:
15374 return NULL;
15375 }
15376
15377
15378 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15379 PyObject *resultobj;
15380 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15381 wxEvent *arg2 = 0 ;
15382 PyObject * obj0 = 0 ;
15383 PyObject * obj1 = 0 ;
15384 char *kwnames[] = {
15385 (char *) "self",(char *) "event", NULL
15386 };
15387
15388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15390 if (SWIG_arg_fail(1)) SWIG_fail;
15391 {
15392 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15393 if (SWIG_arg_fail(2)) SWIG_fail;
15394 if (arg2 == NULL) {
15395 SWIG_null_ref("wxEvent");
15396 }
15397 if (SWIG_arg_fail(2)) SWIG_fail;
15398 }
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 (arg1)->AddPendingEvent(*arg2);
15402
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 Py_INCREF(Py_None); resultobj = Py_None;
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj;
15415 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15416 PyObject * obj0 = 0 ;
15417 char *kwnames[] = {
15418 (char *) "self", NULL
15419 };
15420
15421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15423 if (SWIG_arg_fail(1)) SWIG_fail;
15424 {
15425 PyThreadState* __tstate = wxPyBeginAllowThreads();
15426 (arg1)->ProcessPendingEvents();
15427
15428 wxPyEndAllowThreads(__tstate);
15429 if (PyErr_Occurred()) SWIG_fail;
15430 }
15431 Py_INCREF(Py_None); resultobj = Py_None;
15432 return resultobj;
15433 fail:
15434 return NULL;
15435 }
15436
15437
15438 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15439 PyObject *resultobj;
15440 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15441 int arg2 ;
15442 int arg3 ;
15443 int arg4 ;
15444 PyObject *arg5 = (PyObject *) 0 ;
15445 PyObject * obj0 = 0 ;
15446 PyObject * obj1 = 0 ;
15447 PyObject * obj2 = 0 ;
15448 PyObject * obj3 = 0 ;
15449 PyObject * obj4 = 0 ;
15450 char *kwnames[] = {
15451 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15452 };
15453
15454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15456 if (SWIG_arg_fail(1)) SWIG_fail;
15457 {
15458 arg2 = (int)(SWIG_As_int(obj1));
15459 if (SWIG_arg_fail(2)) SWIG_fail;
15460 }
15461 {
15462 arg3 = (int)(SWIG_As_int(obj2));
15463 if (SWIG_arg_fail(3)) SWIG_fail;
15464 }
15465 {
15466 arg4 = (int)(SWIG_As_int(obj3));
15467 if (SWIG_arg_fail(4)) SWIG_fail;
15468 }
15469 arg5 = obj4;
15470 {
15471 PyThreadState* __tstate = wxPyBeginAllowThreads();
15472 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15473
15474 wxPyEndAllowThreads(__tstate);
15475 if (PyErr_Occurred()) SWIG_fail;
15476 }
15477 Py_INCREF(Py_None); resultobj = Py_None;
15478 return resultobj;
15479 fail:
15480 return NULL;
15481 }
15482
15483
15484 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15485 PyObject *resultobj;
15486 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15487 int arg2 ;
15488 int arg3 = (int) -1 ;
15489 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15490 bool result;
15491 PyObject * obj0 = 0 ;
15492 PyObject * obj1 = 0 ;
15493 PyObject * obj2 = 0 ;
15494 PyObject * obj3 = 0 ;
15495 char *kwnames[] = {
15496 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15497 };
15498
15499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15501 if (SWIG_arg_fail(1)) SWIG_fail;
15502 {
15503 arg2 = (int)(SWIG_As_int(obj1));
15504 if (SWIG_arg_fail(2)) SWIG_fail;
15505 }
15506 if (obj2) {
15507 {
15508 arg3 = (int)(SWIG_As_int(obj2));
15509 if (SWIG_arg_fail(3)) SWIG_fail;
15510 }
15511 }
15512 if (obj3) {
15513 {
15514 arg4 = (wxEventType)(SWIG_As_int(obj3));
15515 if (SWIG_arg_fail(4)) SWIG_fail;
15516 }
15517 }
15518 {
15519 PyThreadState* __tstate = wxPyBeginAllowThreads();
15520 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15521
15522 wxPyEndAllowThreads(__tstate);
15523 if (PyErr_Occurred()) SWIG_fail;
15524 }
15525 {
15526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15527 }
15528 return resultobj;
15529 fail:
15530 return NULL;
15531 }
15532
15533
15534 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15535 PyObject *resultobj;
15536 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15537 PyObject *arg2 = (PyObject *) 0 ;
15538 bool arg3 = (bool) true ;
15539 PyObject * obj0 = 0 ;
15540 PyObject * obj1 = 0 ;
15541 PyObject * obj2 = 0 ;
15542 char *kwnames[] = {
15543 (char *) "self",(char *) "_self",(char *) "incref", NULL
15544 };
15545
15546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15548 if (SWIG_arg_fail(1)) SWIG_fail;
15549 arg2 = obj1;
15550 if (obj2) {
15551 {
15552 arg3 = (bool)(SWIG_As_bool(obj2));
15553 if (SWIG_arg_fail(3)) SWIG_fail;
15554 }
15555 }
15556 {
15557 PyThreadState* __tstate = wxPyBeginAllowThreads();
15558 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15559
15560 wxPyEndAllowThreads(__tstate);
15561 if (PyErr_Occurred()) SWIG_fail;
15562 }
15563 Py_INCREF(Py_None); resultobj = Py_None;
15564 return resultobj;
15565 fail:
15566 return NULL;
15567 }
15568
15569
15570 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15571 PyObject *obj;
15572 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15573 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15574 Py_INCREF(obj);
15575 return Py_BuildValue((char *)"");
15576 }
15577 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15578 PyObject *resultobj;
15579 wxEventType result;
15580 char *kwnames[] = {
15581 NULL
15582 };
15583
15584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 result = (wxEventType)wxNewEventType();
15588
15589 wxPyEndAllowThreads(__tstate);
15590 if (PyErr_Occurred()) SWIG_fail;
15591 }
15592 {
15593 resultobj = SWIG_From_int((int)(result));
15594 }
15595 return resultobj;
15596 fail:
15597 return NULL;
15598 }
15599
15600
15601 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15602 PyObject *resultobj;
15603 wxEvent *arg1 = (wxEvent *) 0 ;
15604 PyObject * obj0 = 0 ;
15605 char *kwnames[] = {
15606 (char *) "self", NULL
15607 };
15608
15609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15611 if (SWIG_arg_fail(1)) SWIG_fail;
15612 {
15613 PyThreadState* __tstate = wxPyBeginAllowThreads();
15614 delete arg1;
15615
15616 wxPyEndAllowThreads(__tstate);
15617 if (PyErr_Occurred()) SWIG_fail;
15618 }
15619 Py_INCREF(Py_None); resultobj = Py_None;
15620 return resultobj;
15621 fail:
15622 return NULL;
15623 }
15624
15625
15626 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15627 PyObject *resultobj;
15628 wxEvent *arg1 = (wxEvent *) 0 ;
15629 wxEventType arg2 ;
15630 PyObject * obj0 = 0 ;
15631 PyObject * obj1 = 0 ;
15632 char *kwnames[] = {
15633 (char *) "self",(char *) "typ", NULL
15634 };
15635
15636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15638 if (SWIG_arg_fail(1)) SWIG_fail;
15639 {
15640 arg2 = (wxEventType)(SWIG_As_int(obj1));
15641 if (SWIG_arg_fail(2)) SWIG_fail;
15642 }
15643 {
15644 PyThreadState* __tstate = wxPyBeginAllowThreads();
15645 (arg1)->SetEventType(arg2);
15646
15647 wxPyEndAllowThreads(__tstate);
15648 if (PyErr_Occurred()) SWIG_fail;
15649 }
15650 Py_INCREF(Py_None); resultobj = Py_None;
15651 return resultobj;
15652 fail:
15653 return NULL;
15654 }
15655
15656
15657 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15658 PyObject *resultobj;
15659 wxEvent *arg1 = (wxEvent *) 0 ;
15660 wxEventType result;
15661 PyObject * obj0 = 0 ;
15662 char *kwnames[] = {
15663 (char *) "self", NULL
15664 };
15665
15666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15668 if (SWIG_arg_fail(1)) SWIG_fail;
15669 {
15670 PyThreadState* __tstate = wxPyBeginAllowThreads();
15671 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15672
15673 wxPyEndAllowThreads(__tstate);
15674 if (PyErr_Occurred()) SWIG_fail;
15675 }
15676 {
15677 resultobj = SWIG_From_int((int)(result));
15678 }
15679 return resultobj;
15680 fail:
15681 return NULL;
15682 }
15683
15684
15685 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15686 PyObject *resultobj;
15687 wxEvent *arg1 = (wxEvent *) 0 ;
15688 wxObject *result;
15689 PyObject * obj0 = 0 ;
15690 char *kwnames[] = {
15691 (char *) "self", NULL
15692 };
15693
15694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15696 if (SWIG_arg_fail(1)) SWIG_fail;
15697 {
15698 PyThreadState* __tstate = wxPyBeginAllowThreads();
15699 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15700
15701 wxPyEndAllowThreads(__tstate);
15702 if (PyErr_Occurred()) SWIG_fail;
15703 }
15704 {
15705 resultobj = wxPyMake_wxObject(result, 0);
15706 }
15707 return resultobj;
15708 fail:
15709 return NULL;
15710 }
15711
15712
15713 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15714 PyObject *resultobj;
15715 wxEvent *arg1 = (wxEvent *) 0 ;
15716 wxObject *arg2 = (wxObject *) 0 ;
15717 PyObject * obj0 = 0 ;
15718 PyObject * obj1 = 0 ;
15719 char *kwnames[] = {
15720 (char *) "self",(char *) "obj", NULL
15721 };
15722
15723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15725 if (SWIG_arg_fail(1)) SWIG_fail;
15726 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15727 if (SWIG_arg_fail(2)) SWIG_fail;
15728 {
15729 PyThreadState* __tstate = wxPyBeginAllowThreads();
15730 (arg1)->SetEventObject(arg2);
15731
15732 wxPyEndAllowThreads(__tstate);
15733 if (PyErr_Occurred()) SWIG_fail;
15734 }
15735 Py_INCREF(Py_None); resultobj = Py_None;
15736 return resultobj;
15737 fail:
15738 return NULL;
15739 }
15740
15741
15742 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15743 PyObject *resultobj;
15744 wxEvent *arg1 = (wxEvent *) 0 ;
15745 long result;
15746 PyObject * obj0 = 0 ;
15747 char *kwnames[] = {
15748 (char *) "self", NULL
15749 };
15750
15751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15753 if (SWIG_arg_fail(1)) SWIG_fail;
15754 {
15755 PyThreadState* __tstate = wxPyBeginAllowThreads();
15756 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15757
15758 wxPyEndAllowThreads(__tstate);
15759 if (PyErr_Occurred()) SWIG_fail;
15760 }
15761 {
15762 resultobj = SWIG_From_long((long)(result));
15763 }
15764 return resultobj;
15765 fail:
15766 return NULL;
15767 }
15768
15769
15770 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15771 PyObject *resultobj;
15772 wxEvent *arg1 = (wxEvent *) 0 ;
15773 long arg2 = (long) 0 ;
15774 PyObject * obj0 = 0 ;
15775 PyObject * obj1 = 0 ;
15776 char *kwnames[] = {
15777 (char *) "self",(char *) "ts", NULL
15778 };
15779
15780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15782 if (SWIG_arg_fail(1)) SWIG_fail;
15783 if (obj1) {
15784 {
15785 arg2 = (long)(SWIG_As_long(obj1));
15786 if (SWIG_arg_fail(2)) SWIG_fail;
15787 }
15788 }
15789 {
15790 PyThreadState* __tstate = wxPyBeginAllowThreads();
15791 (arg1)->SetTimestamp(arg2);
15792
15793 wxPyEndAllowThreads(__tstate);
15794 if (PyErr_Occurred()) SWIG_fail;
15795 }
15796 Py_INCREF(Py_None); resultobj = Py_None;
15797 return resultobj;
15798 fail:
15799 return NULL;
15800 }
15801
15802
15803 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15804 PyObject *resultobj;
15805 wxEvent *arg1 = (wxEvent *) 0 ;
15806 int result;
15807 PyObject * obj0 = 0 ;
15808 char *kwnames[] = {
15809 (char *) "self", NULL
15810 };
15811
15812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15814 if (SWIG_arg_fail(1)) SWIG_fail;
15815 {
15816 PyThreadState* __tstate = wxPyBeginAllowThreads();
15817 result = (int)((wxEvent const *)arg1)->GetId();
15818
15819 wxPyEndAllowThreads(__tstate);
15820 if (PyErr_Occurred()) SWIG_fail;
15821 }
15822 {
15823 resultobj = SWIG_From_int((int)(result));
15824 }
15825 return resultobj;
15826 fail:
15827 return NULL;
15828 }
15829
15830
15831 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15832 PyObject *resultobj;
15833 wxEvent *arg1 = (wxEvent *) 0 ;
15834 int arg2 ;
15835 PyObject * obj0 = 0 ;
15836 PyObject * obj1 = 0 ;
15837 char *kwnames[] = {
15838 (char *) "self",(char *) "Id", NULL
15839 };
15840
15841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15843 if (SWIG_arg_fail(1)) SWIG_fail;
15844 {
15845 arg2 = (int)(SWIG_As_int(obj1));
15846 if (SWIG_arg_fail(2)) SWIG_fail;
15847 }
15848 {
15849 PyThreadState* __tstate = wxPyBeginAllowThreads();
15850 (arg1)->SetId(arg2);
15851
15852 wxPyEndAllowThreads(__tstate);
15853 if (PyErr_Occurred()) SWIG_fail;
15854 }
15855 Py_INCREF(Py_None); resultobj = Py_None;
15856 return resultobj;
15857 fail:
15858 return NULL;
15859 }
15860
15861
15862 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15863 PyObject *resultobj;
15864 wxEvent *arg1 = (wxEvent *) 0 ;
15865 bool result;
15866 PyObject * obj0 = 0 ;
15867 char *kwnames[] = {
15868 (char *) "self", NULL
15869 };
15870
15871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15873 if (SWIG_arg_fail(1)) SWIG_fail;
15874 {
15875 PyThreadState* __tstate = wxPyBeginAllowThreads();
15876 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15877
15878 wxPyEndAllowThreads(__tstate);
15879 if (PyErr_Occurred()) SWIG_fail;
15880 }
15881 {
15882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15883 }
15884 return resultobj;
15885 fail:
15886 return NULL;
15887 }
15888
15889
15890 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15891 PyObject *resultobj;
15892 wxEvent *arg1 = (wxEvent *) 0 ;
15893 bool arg2 = (bool) true ;
15894 PyObject * obj0 = 0 ;
15895 PyObject * obj1 = 0 ;
15896 char *kwnames[] = {
15897 (char *) "self",(char *) "skip", NULL
15898 };
15899
15900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15902 if (SWIG_arg_fail(1)) SWIG_fail;
15903 if (obj1) {
15904 {
15905 arg2 = (bool)(SWIG_As_bool(obj1));
15906 if (SWIG_arg_fail(2)) SWIG_fail;
15907 }
15908 }
15909 {
15910 PyThreadState* __tstate = wxPyBeginAllowThreads();
15911 (arg1)->Skip(arg2);
15912
15913 wxPyEndAllowThreads(__tstate);
15914 if (PyErr_Occurred()) SWIG_fail;
15915 }
15916 Py_INCREF(Py_None); resultobj = Py_None;
15917 return resultobj;
15918 fail:
15919 return NULL;
15920 }
15921
15922
15923 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15924 PyObject *resultobj;
15925 wxEvent *arg1 = (wxEvent *) 0 ;
15926 bool result;
15927 PyObject * obj0 = 0 ;
15928 char *kwnames[] = {
15929 (char *) "self", NULL
15930 };
15931
15932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15934 if (SWIG_arg_fail(1)) SWIG_fail;
15935 {
15936 PyThreadState* __tstate = wxPyBeginAllowThreads();
15937 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15938
15939 wxPyEndAllowThreads(__tstate);
15940 if (PyErr_Occurred()) SWIG_fail;
15941 }
15942 {
15943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15944 }
15945 return resultobj;
15946 fail:
15947 return NULL;
15948 }
15949
15950
15951 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15952 PyObject *resultobj;
15953 wxEvent *arg1 = (wxEvent *) 0 ;
15954 bool result;
15955 PyObject * obj0 = 0 ;
15956 char *kwnames[] = {
15957 (char *) "self", NULL
15958 };
15959
15960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15962 if (SWIG_arg_fail(1)) SWIG_fail;
15963 {
15964 PyThreadState* __tstate = wxPyBeginAllowThreads();
15965 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15966
15967 wxPyEndAllowThreads(__tstate);
15968 if (PyErr_Occurred()) SWIG_fail;
15969 }
15970 {
15971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15972 }
15973 return resultobj;
15974 fail:
15975 return NULL;
15976 }
15977
15978
15979 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15980 PyObject *resultobj;
15981 wxEvent *arg1 = (wxEvent *) 0 ;
15982 int result;
15983 PyObject * obj0 = 0 ;
15984 char *kwnames[] = {
15985 (char *) "self", NULL
15986 };
15987
15988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15990 if (SWIG_arg_fail(1)) SWIG_fail;
15991 {
15992 PyThreadState* __tstate = wxPyBeginAllowThreads();
15993 result = (int)(arg1)->StopPropagation();
15994
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 {
15999 resultobj = SWIG_From_int((int)(result));
16000 }
16001 return resultobj;
16002 fail:
16003 return NULL;
16004 }
16005
16006
16007 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16008 PyObject *resultobj;
16009 wxEvent *arg1 = (wxEvent *) 0 ;
16010 int arg2 ;
16011 PyObject * obj0 = 0 ;
16012 PyObject * obj1 = 0 ;
16013 char *kwnames[] = {
16014 (char *) "self",(char *) "propagationLevel", NULL
16015 };
16016
16017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
16018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16019 if (SWIG_arg_fail(1)) SWIG_fail;
16020 {
16021 arg2 = (int)(SWIG_As_int(obj1));
16022 if (SWIG_arg_fail(2)) SWIG_fail;
16023 }
16024 {
16025 PyThreadState* __tstate = wxPyBeginAllowThreads();
16026 (arg1)->ResumePropagation(arg2);
16027
16028 wxPyEndAllowThreads(__tstate);
16029 if (PyErr_Occurred()) SWIG_fail;
16030 }
16031 Py_INCREF(Py_None); resultobj = Py_None;
16032 return resultobj;
16033 fail:
16034 return NULL;
16035 }
16036
16037
16038 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16039 PyObject *resultobj;
16040 wxEvent *arg1 = (wxEvent *) 0 ;
16041 wxEvent *result;
16042 PyObject * obj0 = 0 ;
16043 char *kwnames[] = {
16044 (char *) "self", NULL
16045 };
16046
16047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16049 if (SWIG_arg_fail(1)) SWIG_fail;
16050 {
16051 PyThreadState* __tstate = wxPyBeginAllowThreads();
16052 result = (wxEvent *)(arg1)->Clone();
16053
16054 wxPyEndAllowThreads(__tstate);
16055 if (PyErr_Occurred()) SWIG_fail;
16056 }
16057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16058 return resultobj;
16059 fail:
16060 return NULL;
16061 }
16062
16063
16064 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16065 PyObject *obj;
16066 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16067 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16068 Py_INCREF(obj);
16069 return Py_BuildValue((char *)"");
16070 }
16071 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16072 PyObject *resultobj;
16073 wxEvent *arg1 = 0 ;
16074 wxPropagationDisabler *result;
16075 PyObject * obj0 = 0 ;
16076 char *kwnames[] = {
16077 (char *) "event", NULL
16078 };
16079
16080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16081 {
16082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16083 if (SWIG_arg_fail(1)) SWIG_fail;
16084 if (arg1 == NULL) {
16085 SWIG_null_ref("wxEvent");
16086 }
16087 if (SWIG_arg_fail(1)) SWIG_fail;
16088 }
16089 {
16090 PyThreadState* __tstate = wxPyBeginAllowThreads();
16091 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16092
16093 wxPyEndAllowThreads(__tstate);
16094 if (PyErr_Occurred()) SWIG_fail;
16095 }
16096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16097 return resultobj;
16098 fail:
16099 return NULL;
16100 }
16101
16102
16103 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16104 PyObject *resultobj;
16105 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16106 PyObject * obj0 = 0 ;
16107 char *kwnames[] = {
16108 (char *) "self", NULL
16109 };
16110
16111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16113 if (SWIG_arg_fail(1)) SWIG_fail;
16114 {
16115 PyThreadState* __tstate = wxPyBeginAllowThreads();
16116 delete arg1;
16117
16118 wxPyEndAllowThreads(__tstate);
16119 if (PyErr_Occurred()) SWIG_fail;
16120 }
16121 Py_INCREF(Py_None); resultobj = Py_None;
16122 return resultobj;
16123 fail:
16124 return NULL;
16125 }
16126
16127
16128 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16129 PyObject *obj;
16130 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16131 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16132 Py_INCREF(obj);
16133 return Py_BuildValue((char *)"");
16134 }
16135 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16136 PyObject *resultobj;
16137 wxEvent *arg1 = 0 ;
16138 wxPropagateOnce *result;
16139 PyObject * obj0 = 0 ;
16140 char *kwnames[] = {
16141 (char *) "event", NULL
16142 };
16143
16144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16145 {
16146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16147 if (SWIG_arg_fail(1)) SWIG_fail;
16148 if (arg1 == NULL) {
16149 SWIG_null_ref("wxEvent");
16150 }
16151 if (SWIG_arg_fail(1)) SWIG_fail;
16152 }
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16156
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16161 return resultobj;
16162 fail:
16163 return NULL;
16164 }
16165
16166
16167 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16168 PyObject *resultobj;
16169 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16170 PyObject * obj0 = 0 ;
16171 char *kwnames[] = {
16172 (char *) "self", NULL
16173 };
16174
16175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16177 if (SWIG_arg_fail(1)) SWIG_fail;
16178 {
16179 PyThreadState* __tstate = wxPyBeginAllowThreads();
16180 delete arg1;
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 * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16193 PyObject *obj;
16194 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16195 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16196 Py_INCREF(obj);
16197 return Py_BuildValue((char *)"");
16198 }
16199 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16200 PyObject *resultobj;
16201 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16202 int arg2 = (int) 0 ;
16203 wxCommandEvent *result;
16204 PyObject * obj0 = 0 ;
16205 PyObject * obj1 = 0 ;
16206 char *kwnames[] = {
16207 (char *) "commandType",(char *) "winid", NULL
16208 };
16209
16210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16211 if (obj0) {
16212 {
16213 arg1 = (wxEventType)(SWIG_As_int(obj0));
16214 if (SWIG_arg_fail(1)) SWIG_fail;
16215 }
16216 }
16217 if (obj1) {
16218 {
16219 arg2 = (int)(SWIG_As_int(obj1));
16220 if (SWIG_arg_fail(2)) SWIG_fail;
16221 }
16222 }
16223 {
16224 PyThreadState* __tstate = wxPyBeginAllowThreads();
16225 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16226
16227 wxPyEndAllowThreads(__tstate);
16228 if (PyErr_Occurred()) SWIG_fail;
16229 }
16230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16231 return resultobj;
16232 fail:
16233 return NULL;
16234 }
16235
16236
16237 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16238 PyObject *resultobj;
16239 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16240 int result;
16241 PyObject * obj0 = 0 ;
16242 char *kwnames[] = {
16243 (char *) "self", NULL
16244 };
16245
16246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16248 if (SWIG_arg_fail(1)) SWIG_fail;
16249 {
16250 PyThreadState* __tstate = wxPyBeginAllowThreads();
16251 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16252
16253 wxPyEndAllowThreads(__tstate);
16254 if (PyErr_Occurred()) SWIG_fail;
16255 }
16256 {
16257 resultobj = SWIG_From_int((int)(result));
16258 }
16259 return resultobj;
16260 fail:
16261 return NULL;
16262 }
16263
16264
16265 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16266 PyObject *resultobj;
16267 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16268 wxString *arg2 = 0 ;
16269 bool temp2 = false ;
16270 PyObject * obj0 = 0 ;
16271 PyObject * obj1 = 0 ;
16272 char *kwnames[] = {
16273 (char *) "self",(char *) "s", NULL
16274 };
16275
16276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16278 if (SWIG_arg_fail(1)) SWIG_fail;
16279 {
16280 arg2 = wxString_in_helper(obj1);
16281 if (arg2 == NULL) SWIG_fail;
16282 temp2 = true;
16283 }
16284 {
16285 PyThreadState* __tstate = wxPyBeginAllowThreads();
16286 (arg1)->SetString((wxString const &)*arg2);
16287
16288 wxPyEndAllowThreads(__tstate);
16289 if (PyErr_Occurred()) SWIG_fail;
16290 }
16291 Py_INCREF(Py_None); resultobj = Py_None;
16292 {
16293 if (temp2)
16294 delete arg2;
16295 }
16296 return resultobj;
16297 fail:
16298 {
16299 if (temp2)
16300 delete arg2;
16301 }
16302 return NULL;
16303 }
16304
16305
16306 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16307 PyObject *resultobj;
16308 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16309 wxString result;
16310 PyObject * obj0 = 0 ;
16311 char *kwnames[] = {
16312 (char *) "self", NULL
16313 };
16314
16315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16317 if (SWIG_arg_fail(1)) SWIG_fail;
16318 {
16319 PyThreadState* __tstate = wxPyBeginAllowThreads();
16320 result = ((wxCommandEvent const *)arg1)->GetString();
16321
16322 wxPyEndAllowThreads(__tstate);
16323 if (PyErr_Occurred()) SWIG_fail;
16324 }
16325 {
16326 #if wxUSE_UNICODE
16327 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16328 #else
16329 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16330 #endif
16331 }
16332 return resultobj;
16333 fail:
16334 return NULL;
16335 }
16336
16337
16338 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16339 PyObject *resultobj;
16340 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16341 bool result;
16342 PyObject * obj0 = 0 ;
16343 char *kwnames[] = {
16344 (char *) "self", NULL
16345 };
16346
16347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16349 if (SWIG_arg_fail(1)) SWIG_fail;
16350 {
16351 PyThreadState* __tstate = wxPyBeginAllowThreads();
16352 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16353
16354 wxPyEndAllowThreads(__tstate);
16355 if (PyErr_Occurred()) SWIG_fail;
16356 }
16357 {
16358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16359 }
16360 return resultobj;
16361 fail:
16362 return NULL;
16363 }
16364
16365
16366 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16367 PyObject *resultobj;
16368 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16369 bool result;
16370 PyObject * obj0 = 0 ;
16371 char *kwnames[] = {
16372 (char *) "self", NULL
16373 };
16374
16375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16377 if (SWIG_arg_fail(1)) SWIG_fail;
16378 {
16379 PyThreadState* __tstate = wxPyBeginAllowThreads();
16380 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16381
16382 wxPyEndAllowThreads(__tstate);
16383 if (PyErr_Occurred()) SWIG_fail;
16384 }
16385 {
16386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16387 }
16388 return resultobj;
16389 fail:
16390 return NULL;
16391 }
16392
16393
16394 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16395 PyObject *resultobj;
16396 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16397 long arg2 ;
16398 PyObject * obj0 = 0 ;
16399 PyObject * obj1 = 0 ;
16400 char *kwnames[] = {
16401 (char *) "self",(char *) "extraLong", NULL
16402 };
16403
16404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16406 if (SWIG_arg_fail(1)) SWIG_fail;
16407 {
16408 arg2 = (long)(SWIG_As_long(obj1));
16409 if (SWIG_arg_fail(2)) SWIG_fail;
16410 }
16411 {
16412 PyThreadState* __tstate = wxPyBeginAllowThreads();
16413 (arg1)->SetExtraLong(arg2);
16414
16415 wxPyEndAllowThreads(__tstate);
16416 if (PyErr_Occurred()) SWIG_fail;
16417 }
16418 Py_INCREF(Py_None); resultobj = Py_None;
16419 return resultobj;
16420 fail:
16421 return NULL;
16422 }
16423
16424
16425 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16426 PyObject *resultobj;
16427 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16428 long result;
16429 PyObject * obj0 = 0 ;
16430 char *kwnames[] = {
16431 (char *) "self", NULL
16432 };
16433
16434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16436 if (SWIG_arg_fail(1)) SWIG_fail;
16437 {
16438 PyThreadState* __tstate = wxPyBeginAllowThreads();
16439 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16440
16441 wxPyEndAllowThreads(__tstate);
16442 if (PyErr_Occurred()) SWIG_fail;
16443 }
16444 {
16445 resultobj = SWIG_From_long((long)(result));
16446 }
16447 return resultobj;
16448 fail:
16449 return NULL;
16450 }
16451
16452
16453 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16454 PyObject *resultobj;
16455 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16456 int arg2 ;
16457 PyObject * obj0 = 0 ;
16458 PyObject * obj1 = 0 ;
16459 char *kwnames[] = {
16460 (char *) "self",(char *) "i", NULL
16461 };
16462
16463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16465 if (SWIG_arg_fail(1)) SWIG_fail;
16466 {
16467 arg2 = (int)(SWIG_As_int(obj1));
16468 if (SWIG_arg_fail(2)) SWIG_fail;
16469 }
16470 {
16471 PyThreadState* __tstate = wxPyBeginAllowThreads();
16472 (arg1)->SetInt(arg2);
16473
16474 wxPyEndAllowThreads(__tstate);
16475 if (PyErr_Occurred()) SWIG_fail;
16476 }
16477 Py_INCREF(Py_None); resultobj = Py_None;
16478 return resultobj;
16479 fail:
16480 return NULL;
16481 }
16482
16483
16484 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16485 PyObject *resultobj;
16486 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16487 long result;
16488 PyObject * obj0 = 0 ;
16489 char *kwnames[] = {
16490 (char *) "self", NULL
16491 };
16492
16493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16495 if (SWIG_arg_fail(1)) SWIG_fail;
16496 {
16497 PyThreadState* __tstate = wxPyBeginAllowThreads();
16498 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16499
16500 wxPyEndAllowThreads(__tstate);
16501 if (PyErr_Occurred()) SWIG_fail;
16502 }
16503 {
16504 resultobj = SWIG_From_long((long)(result));
16505 }
16506 return resultobj;
16507 fail:
16508 return NULL;
16509 }
16510
16511
16512 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16513 PyObject *resultobj;
16514 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16515 wxEvent *result;
16516 PyObject * obj0 = 0 ;
16517 char *kwnames[] = {
16518 (char *) "self", NULL
16519 };
16520
16521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16523 if (SWIG_arg_fail(1)) SWIG_fail;
16524 {
16525 PyThreadState* __tstate = wxPyBeginAllowThreads();
16526 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16527
16528 wxPyEndAllowThreads(__tstate);
16529 if (PyErr_Occurred()) SWIG_fail;
16530 }
16531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16532 return resultobj;
16533 fail:
16534 return NULL;
16535 }
16536
16537
16538 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16539 PyObject *obj;
16540 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16541 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16542 Py_INCREF(obj);
16543 return Py_BuildValue((char *)"");
16544 }
16545 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16546 PyObject *resultobj;
16547 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16548 int arg2 = (int) 0 ;
16549 wxNotifyEvent *result;
16550 PyObject * obj0 = 0 ;
16551 PyObject * obj1 = 0 ;
16552 char *kwnames[] = {
16553 (char *) "commandType",(char *) "winid", NULL
16554 };
16555
16556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16557 if (obj0) {
16558 {
16559 arg1 = (wxEventType)(SWIG_As_int(obj0));
16560 if (SWIG_arg_fail(1)) SWIG_fail;
16561 }
16562 }
16563 if (obj1) {
16564 {
16565 arg2 = (int)(SWIG_As_int(obj1));
16566 if (SWIG_arg_fail(2)) SWIG_fail;
16567 }
16568 }
16569 {
16570 PyThreadState* __tstate = wxPyBeginAllowThreads();
16571 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16572
16573 wxPyEndAllowThreads(__tstate);
16574 if (PyErr_Occurred()) SWIG_fail;
16575 }
16576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16577 return resultobj;
16578 fail:
16579 return NULL;
16580 }
16581
16582
16583 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16584 PyObject *resultobj;
16585 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16586 PyObject * obj0 = 0 ;
16587 char *kwnames[] = {
16588 (char *) "self", NULL
16589 };
16590
16591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16593 if (SWIG_arg_fail(1)) SWIG_fail;
16594 {
16595 PyThreadState* __tstate = wxPyBeginAllowThreads();
16596 (arg1)->Veto();
16597
16598 wxPyEndAllowThreads(__tstate);
16599 if (PyErr_Occurred()) SWIG_fail;
16600 }
16601 Py_INCREF(Py_None); resultobj = Py_None;
16602 return resultobj;
16603 fail:
16604 return NULL;
16605 }
16606
16607
16608 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16609 PyObject *resultobj;
16610 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16611 PyObject * obj0 = 0 ;
16612 char *kwnames[] = {
16613 (char *) "self", NULL
16614 };
16615
16616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16618 if (SWIG_arg_fail(1)) SWIG_fail;
16619 {
16620 PyThreadState* __tstate = wxPyBeginAllowThreads();
16621 (arg1)->Allow();
16622
16623 wxPyEndAllowThreads(__tstate);
16624 if (PyErr_Occurred()) SWIG_fail;
16625 }
16626 Py_INCREF(Py_None); resultobj = Py_None;
16627 return resultobj;
16628 fail:
16629 return NULL;
16630 }
16631
16632
16633 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16634 PyObject *resultobj;
16635 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16636 bool result;
16637 PyObject * obj0 = 0 ;
16638 char *kwnames[] = {
16639 (char *) "self", NULL
16640 };
16641
16642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16644 if (SWIG_arg_fail(1)) SWIG_fail;
16645 {
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 result = (bool)(arg1)->IsAllowed();
16648
16649 wxPyEndAllowThreads(__tstate);
16650 if (PyErr_Occurred()) SWIG_fail;
16651 }
16652 {
16653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16654 }
16655 return resultobj;
16656 fail:
16657 return NULL;
16658 }
16659
16660
16661 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16662 PyObject *obj;
16663 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16664 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16665 Py_INCREF(obj);
16666 return Py_BuildValue((char *)"");
16667 }
16668 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj;
16670 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16671 int arg2 = (int) 0 ;
16672 int arg3 = (int) 0 ;
16673 int arg4 = (int) 0 ;
16674 wxScrollEvent *result;
16675 PyObject * obj0 = 0 ;
16676 PyObject * obj1 = 0 ;
16677 PyObject * obj2 = 0 ;
16678 PyObject * obj3 = 0 ;
16679 char *kwnames[] = {
16680 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16681 };
16682
16683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16684 if (obj0) {
16685 {
16686 arg1 = (wxEventType)(SWIG_As_int(obj0));
16687 if (SWIG_arg_fail(1)) SWIG_fail;
16688 }
16689 }
16690 if (obj1) {
16691 {
16692 arg2 = (int)(SWIG_As_int(obj1));
16693 if (SWIG_arg_fail(2)) SWIG_fail;
16694 }
16695 }
16696 if (obj2) {
16697 {
16698 arg3 = (int)(SWIG_As_int(obj2));
16699 if (SWIG_arg_fail(3)) SWIG_fail;
16700 }
16701 }
16702 if (obj3) {
16703 {
16704 arg4 = (int)(SWIG_As_int(obj3));
16705 if (SWIG_arg_fail(4)) SWIG_fail;
16706 }
16707 }
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16711
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj;
16724 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16725 int result;
16726 PyObject * obj0 = 0 ;
16727 char *kwnames[] = {
16728 (char *) "self", NULL
16729 };
16730
16731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16733 if (SWIG_arg_fail(1)) SWIG_fail;
16734 {
16735 PyThreadState* __tstate = wxPyBeginAllowThreads();
16736 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16737
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 {
16742 resultobj = SWIG_From_int((int)(result));
16743 }
16744 return resultobj;
16745 fail:
16746 return NULL;
16747 }
16748
16749
16750 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16751 PyObject *resultobj;
16752 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16753 int result;
16754 PyObject * obj0 = 0 ;
16755 char *kwnames[] = {
16756 (char *) "self", NULL
16757 };
16758
16759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16761 if (SWIG_arg_fail(1)) SWIG_fail;
16762 {
16763 PyThreadState* __tstate = wxPyBeginAllowThreads();
16764 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16765
16766 wxPyEndAllowThreads(__tstate);
16767 if (PyErr_Occurred()) SWIG_fail;
16768 }
16769 {
16770 resultobj = SWIG_From_int((int)(result));
16771 }
16772 return resultobj;
16773 fail:
16774 return NULL;
16775 }
16776
16777
16778 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16779 PyObject *resultobj;
16780 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16781 int arg2 ;
16782 PyObject * obj0 = 0 ;
16783 PyObject * obj1 = 0 ;
16784 char *kwnames[] = {
16785 (char *) "self",(char *) "orient", NULL
16786 };
16787
16788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16790 if (SWIG_arg_fail(1)) SWIG_fail;
16791 {
16792 arg2 = (int)(SWIG_As_int(obj1));
16793 if (SWIG_arg_fail(2)) SWIG_fail;
16794 }
16795 {
16796 PyThreadState* __tstate = wxPyBeginAllowThreads();
16797 (arg1)->SetOrientation(arg2);
16798
16799 wxPyEndAllowThreads(__tstate);
16800 if (PyErr_Occurred()) SWIG_fail;
16801 }
16802 Py_INCREF(Py_None); resultobj = Py_None;
16803 return resultobj;
16804 fail:
16805 return NULL;
16806 }
16807
16808
16809 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16810 PyObject *resultobj;
16811 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16812 int arg2 ;
16813 PyObject * obj0 = 0 ;
16814 PyObject * obj1 = 0 ;
16815 char *kwnames[] = {
16816 (char *) "self",(char *) "pos", NULL
16817 };
16818
16819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16821 if (SWIG_arg_fail(1)) SWIG_fail;
16822 {
16823 arg2 = (int)(SWIG_As_int(obj1));
16824 if (SWIG_arg_fail(2)) SWIG_fail;
16825 }
16826 {
16827 PyThreadState* __tstate = wxPyBeginAllowThreads();
16828 (arg1)->SetPosition(arg2);
16829
16830 wxPyEndAllowThreads(__tstate);
16831 if (PyErr_Occurred()) SWIG_fail;
16832 }
16833 Py_INCREF(Py_None); resultobj = Py_None;
16834 return resultobj;
16835 fail:
16836 return NULL;
16837 }
16838
16839
16840 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16841 PyObject *obj;
16842 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16843 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16844 Py_INCREF(obj);
16845 return Py_BuildValue((char *)"");
16846 }
16847 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16848 PyObject *resultobj;
16849 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16850 int arg2 = (int) 0 ;
16851 int arg3 = (int) 0 ;
16852 wxScrollWinEvent *result;
16853 PyObject * obj0 = 0 ;
16854 PyObject * obj1 = 0 ;
16855 PyObject * obj2 = 0 ;
16856 char *kwnames[] = {
16857 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16858 };
16859
16860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16861 if (obj0) {
16862 {
16863 arg1 = (wxEventType)(SWIG_As_int(obj0));
16864 if (SWIG_arg_fail(1)) SWIG_fail;
16865 }
16866 }
16867 if (obj1) {
16868 {
16869 arg2 = (int)(SWIG_As_int(obj1));
16870 if (SWIG_arg_fail(2)) SWIG_fail;
16871 }
16872 }
16873 if (obj2) {
16874 {
16875 arg3 = (int)(SWIG_As_int(obj2));
16876 if (SWIG_arg_fail(3)) SWIG_fail;
16877 }
16878 }
16879 {
16880 PyThreadState* __tstate = wxPyBeginAllowThreads();
16881 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16882
16883 wxPyEndAllowThreads(__tstate);
16884 if (PyErr_Occurred()) SWIG_fail;
16885 }
16886 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16887 return resultobj;
16888 fail:
16889 return NULL;
16890 }
16891
16892
16893 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16894 PyObject *resultobj;
16895 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16896 int result;
16897 PyObject * obj0 = 0 ;
16898 char *kwnames[] = {
16899 (char *) "self", NULL
16900 };
16901
16902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16904 if (SWIG_arg_fail(1)) SWIG_fail;
16905 {
16906 PyThreadState* __tstate = wxPyBeginAllowThreads();
16907 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16908
16909 wxPyEndAllowThreads(__tstate);
16910 if (PyErr_Occurred()) SWIG_fail;
16911 }
16912 {
16913 resultobj = SWIG_From_int((int)(result));
16914 }
16915 return resultobj;
16916 fail:
16917 return NULL;
16918 }
16919
16920
16921 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16922 PyObject *resultobj;
16923 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16924 int result;
16925 PyObject * obj0 = 0 ;
16926 char *kwnames[] = {
16927 (char *) "self", NULL
16928 };
16929
16930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16932 if (SWIG_arg_fail(1)) SWIG_fail;
16933 {
16934 PyThreadState* __tstate = wxPyBeginAllowThreads();
16935 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16936
16937 wxPyEndAllowThreads(__tstate);
16938 if (PyErr_Occurred()) SWIG_fail;
16939 }
16940 {
16941 resultobj = SWIG_From_int((int)(result));
16942 }
16943 return resultobj;
16944 fail:
16945 return NULL;
16946 }
16947
16948
16949 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16950 PyObject *resultobj;
16951 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16952 int arg2 ;
16953 PyObject * obj0 = 0 ;
16954 PyObject * obj1 = 0 ;
16955 char *kwnames[] = {
16956 (char *) "self",(char *) "orient", NULL
16957 };
16958
16959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16961 if (SWIG_arg_fail(1)) SWIG_fail;
16962 {
16963 arg2 = (int)(SWIG_As_int(obj1));
16964 if (SWIG_arg_fail(2)) SWIG_fail;
16965 }
16966 {
16967 PyThreadState* __tstate = wxPyBeginAllowThreads();
16968 (arg1)->SetOrientation(arg2);
16969
16970 wxPyEndAllowThreads(__tstate);
16971 if (PyErr_Occurred()) SWIG_fail;
16972 }
16973 Py_INCREF(Py_None); resultobj = Py_None;
16974 return resultobj;
16975 fail:
16976 return NULL;
16977 }
16978
16979
16980 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16981 PyObject *resultobj;
16982 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16983 int arg2 ;
16984 PyObject * obj0 = 0 ;
16985 PyObject * obj1 = 0 ;
16986 char *kwnames[] = {
16987 (char *) "self",(char *) "pos", NULL
16988 };
16989
16990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16992 if (SWIG_arg_fail(1)) SWIG_fail;
16993 {
16994 arg2 = (int)(SWIG_As_int(obj1));
16995 if (SWIG_arg_fail(2)) SWIG_fail;
16996 }
16997 {
16998 PyThreadState* __tstate = wxPyBeginAllowThreads();
16999 (arg1)->SetPosition(arg2);
17000
17001 wxPyEndAllowThreads(__tstate);
17002 if (PyErr_Occurred()) SWIG_fail;
17003 }
17004 Py_INCREF(Py_None); resultobj = Py_None;
17005 return resultobj;
17006 fail:
17007 return NULL;
17008 }
17009
17010
17011 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
17012 PyObject *obj;
17013 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17014 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
17015 Py_INCREF(obj);
17016 return Py_BuildValue((char *)"");
17017 }
17018 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17019 PyObject *resultobj;
17020 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17021 wxMouseEvent *result;
17022 PyObject * obj0 = 0 ;
17023 char *kwnames[] = {
17024 (char *) "mouseType", NULL
17025 };
17026
17027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17028 if (obj0) {
17029 {
17030 arg1 = (wxEventType)(SWIG_As_int(obj0));
17031 if (SWIG_arg_fail(1)) SWIG_fail;
17032 }
17033 }
17034 {
17035 PyThreadState* __tstate = wxPyBeginAllowThreads();
17036 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17037
17038 wxPyEndAllowThreads(__tstate);
17039 if (PyErr_Occurred()) SWIG_fail;
17040 }
17041 {
17042 resultobj = wxPyMake_wxObject(result, 1);
17043 }
17044 return resultobj;
17045 fail:
17046 return NULL;
17047 }
17048
17049
17050 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17051 PyObject *resultobj;
17052 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17053 bool result;
17054 PyObject * obj0 = 0 ;
17055 char *kwnames[] = {
17056 (char *) "self", NULL
17057 };
17058
17059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17061 if (SWIG_arg_fail(1)) SWIG_fail;
17062 {
17063 PyThreadState* __tstate = wxPyBeginAllowThreads();
17064 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17065
17066 wxPyEndAllowThreads(__tstate);
17067 if (PyErr_Occurred()) SWIG_fail;
17068 }
17069 {
17070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17071 }
17072 return resultobj;
17073 fail:
17074 return NULL;
17075 }
17076
17077
17078 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17079 PyObject *resultobj;
17080 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17081 int arg2 = (int) wxMOUSE_BTN_ANY ;
17082 bool result;
17083 PyObject * obj0 = 0 ;
17084 PyObject * obj1 = 0 ;
17085 char *kwnames[] = {
17086 (char *) "self",(char *) "but", NULL
17087 };
17088
17089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
17090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17091 if (SWIG_arg_fail(1)) SWIG_fail;
17092 if (obj1) {
17093 {
17094 arg2 = (int)(SWIG_As_int(obj1));
17095 if (SWIG_arg_fail(2)) SWIG_fail;
17096 }
17097 }
17098 {
17099 PyThreadState* __tstate = wxPyBeginAllowThreads();
17100 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17101
17102 wxPyEndAllowThreads(__tstate);
17103 if (PyErr_Occurred()) SWIG_fail;
17104 }
17105 {
17106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17107 }
17108 return resultobj;
17109 fail:
17110 return NULL;
17111 }
17112
17113
17114 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17115 PyObject *resultobj;
17116 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17117 int arg2 = (int) wxMOUSE_BTN_ANY ;
17118 bool result;
17119 PyObject * obj0 = 0 ;
17120 PyObject * obj1 = 0 ;
17121 char *kwnames[] = {
17122 (char *) "self",(char *) "but", NULL
17123 };
17124
17125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17127 if (SWIG_arg_fail(1)) SWIG_fail;
17128 if (obj1) {
17129 {
17130 arg2 = (int)(SWIG_As_int(obj1));
17131 if (SWIG_arg_fail(2)) SWIG_fail;
17132 }
17133 }
17134 {
17135 PyThreadState* __tstate = wxPyBeginAllowThreads();
17136 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17137
17138 wxPyEndAllowThreads(__tstate);
17139 if (PyErr_Occurred()) SWIG_fail;
17140 }
17141 {
17142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17143 }
17144 return resultobj;
17145 fail:
17146 return NULL;
17147 }
17148
17149
17150 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17151 PyObject *resultobj;
17152 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17153 int arg2 = (int) wxMOUSE_BTN_ANY ;
17154 bool result;
17155 PyObject * obj0 = 0 ;
17156 PyObject * obj1 = 0 ;
17157 char *kwnames[] = {
17158 (char *) "self",(char *) "but", NULL
17159 };
17160
17161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17163 if (SWIG_arg_fail(1)) SWIG_fail;
17164 if (obj1) {
17165 {
17166 arg2 = (int)(SWIG_As_int(obj1));
17167 if (SWIG_arg_fail(2)) SWIG_fail;
17168 }
17169 }
17170 {
17171 PyThreadState* __tstate = wxPyBeginAllowThreads();
17172 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17173
17174 wxPyEndAllowThreads(__tstate);
17175 if (PyErr_Occurred()) SWIG_fail;
17176 }
17177 {
17178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17179 }
17180 return resultobj;
17181 fail:
17182 return NULL;
17183 }
17184
17185
17186 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17187 PyObject *resultobj;
17188 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17189 int arg2 ;
17190 bool result;
17191 PyObject * obj0 = 0 ;
17192 PyObject * obj1 = 0 ;
17193 char *kwnames[] = {
17194 (char *) "self",(char *) "button", NULL
17195 };
17196
17197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17199 if (SWIG_arg_fail(1)) SWIG_fail;
17200 {
17201 arg2 = (int)(SWIG_As_int(obj1));
17202 if (SWIG_arg_fail(2)) SWIG_fail;
17203 }
17204 {
17205 PyThreadState* __tstate = wxPyBeginAllowThreads();
17206 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17207
17208 wxPyEndAllowThreads(__tstate);
17209 if (PyErr_Occurred()) SWIG_fail;
17210 }
17211 {
17212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17213 }
17214 return resultobj;
17215 fail:
17216 return NULL;
17217 }
17218
17219
17220 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17221 PyObject *resultobj;
17222 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17223 int arg2 ;
17224 bool result;
17225 PyObject * obj0 = 0 ;
17226 PyObject * obj1 = 0 ;
17227 char *kwnames[] = {
17228 (char *) "self",(char *) "but", NULL
17229 };
17230
17231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17233 if (SWIG_arg_fail(1)) SWIG_fail;
17234 {
17235 arg2 = (int)(SWIG_As_int(obj1));
17236 if (SWIG_arg_fail(2)) SWIG_fail;
17237 }
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17241
17242 wxPyEndAllowThreads(__tstate);
17243 if (PyErr_Occurred()) SWIG_fail;
17244 }
17245 {
17246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17247 }
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj;
17256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17257 int result;
17258 PyObject * obj0 = 0 ;
17259 char *kwnames[] = {
17260 (char *) "self", NULL
17261 };
17262
17263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17265 if (SWIG_arg_fail(1)) SWIG_fail;
17266 {
17267 PyThreadState* __tstate = wxPyBeginAllowThreads();
17268 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17269
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 {
17274 resultobj = SWIG_From_int((int)(result));
17275 }
17276 return resultobj;
17277 fail:
17278 return NULL;
17279 }
17280
17281
17282 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17283 PyObject *resultobj;
17284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17285 bool result;
17286 PyObject * obj0 = 0 ;
17287 char *kwnames[] = {
17288 (char *) "self", NULL
17289 };
17290
17291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17293 if (SWIG_arg_fail(1)) SWIG_fail;
17294 {
17295 PyThreadState* __tstate = wxPyBeginAllowThreads();
17296 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17297
17298 wxPyEndAllowThreads(__tstate);
17299 if (PyErr_Occurred()) SWIG_fail;
17300 }
17301 {
17302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17303 }
17304 return resultobj;
17305 fail:
17306 return NULL;
17307 }
17308
17309
17310 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17311 PyObject *resultobj;
17312 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17313 bool result;
17314 PyObject * obj0 = 0 ;
17315 char *kwnames[] = {
17316 (char *) "self", NULL
17317 };
17318
17319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17321 if (SWIG_arg_fail(1)) SWIG_fail;
17322 {
17323 PyThreadState* __tstate = wxPyBeginAllowThreads();
17324 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17325
17326 wxPyEndAllowThreads(__tstate);
17327 if (PyErr_Occurred()) SWIG_fail;
17328 }
17329 {
17330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17331 }
17332 return resultobj;
17333 fail:
17334 return NULL;
17335 }
17336
17337
17338 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17339 PyObject *resultobj;
17340 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17341 bool result;
17342 PyObject * obj0 = 0 ;
17343 char *kwnames[] = {
17344 (char *) "self", NULL
17345 };
17346
17347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17349 if (SWIG_arg_fail(1)) SWIG_fail;
17350 {
17351 PyThreadState* __tstate = wxPyBeginAllowThreads();
17352 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17353
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 {
17358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17359 }
17360 return resultobj;
17361 fail:
17362 return NULL;
17363 }
17364
17365
17366 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17367 PyObject *resultobj;
17368 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17369 bool result;
17370 PyObject * obj0 = 0 ;
17371 char *kwnames[] = {
17372 (char *) "self", NULL
17373 };
17374
17375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17377 if (SWIG_arg_fail(1)) SWIG_fail;
17378 {
17379 PyThreadState* __tstate = wxPyBeginAllowThreads();
17380 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17381
17382 wxPyEndAllowThreads(__tstate);
17383 if (PyErr_Occurred()) SWIG_fail;
17384 }
17385 {
17386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17387 }
17388 return resultobj;
17389 fail:
17390 return NULL;
17391 }
17392
17393
17394 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17395 PyObject *resultobj;
17396 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17397 bool result;
17398 PyObject * obj0 = 0 ;
17399 char *kwnames[] = {
17400 (char *) "self", NULL
17401 };
17402
17403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17405 if (SWIG_arg_fail(1)) SWIG_fail;
17406 {
17407 PyThreadState* __tstate = wxPyBeginAllowThreads();
17408 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17409
17410 wxPyEndAllowThreads(__tstate);
17411 if (PyErr_Occurred()) SWIG_fail;
17412 }
17413 {
17414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17415 }
17416 return resultobj;
17417 fail:
17418 return NULL;
17419 }
17420
17421
17422 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17423 PyObject *resultobj;
17424 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17425 bool result;
17426 PyObject * obj0 = 0 ;
17427 char *kwnames[] = {
17428 (char *) "self", NULL
17429 };
17430
17431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17433 if (SWIG_arg_fail(1)) SWIG_fail;
17434 {
17435 PyThreadState* __tstate = wxPyBeginAllowThreads();
17436 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17437
17438 wxPyEndAllowThreads(__tstate);
17439 if (PyErr_Occurred()) SWIG_fail;
17440 }
17441 {
17442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17443 }
17444 return resultobj;
17445 fail:
17446 return NULL;
17447 }
17448
17449
17450 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17451 PyObject *resultobj;
17452 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17453 bool result;
17454 PyObject * obj0 = 0 ;
17455 char *kwnames[] = {
17456 (char *) "self", NULL
17457 };
17458
17459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17461 if (SWIG_arg_fail(1)) SWIG_fail;
17462 {
17463 PyThreadState* __tstate = wxPyBeginAllowThreads();
17464 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17465
17466 wxPyEndAllowThreads(__tstate);
17467 if (PyErr_Occurred()) SWIG_fail;
17468 }
17469 {
17470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17471 }
17472 return resultobj;
17473 fail:
17474 return NULL;
17475 }
17476
17477
17478 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17479 PyObject *resultobj;
17480 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17481 bool result;
17482 PyObject * obj0 = 0 ;
17483 char *kwnames[] = {
17484 (char *) "self", NULL
17485 };
17486
17487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17489 if (SWIG_arg_fail(1)) SWIG_fail;
17490 {
17491 PyThreadState* __tstate = wxPyBeginAllowThreads();
17492 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17493
17494 wxPyEndAllowThreads(__tstate);
17495 if (PyErr_Occurred()) SWIG_fail;
17496 }
17497 {
17498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17499 }
17500 return resultobj;
17501 fail:
17502 return NULL;
17503 }
17504
17505
17506 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17507 PyObject *resultobj;
17508 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17509 bool result;
17510 PyObject * obj0 = 0 ;
17511 char *kwnames[] = {
17512 (char *) "self", NULL
17513 };
17514
17515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17517 if (SWIG_arg_fail(1)) SWIG_fail;
17518 {
17519 PyThreadState* __tstate = wxPyBeginAllowThreads();
17520 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17521
17522 wxPyEndAllowThreads(__tstate);
17523 if (PyErr_Occurred()) SWIG_fail;
17524 }
17525 {
17526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17527 }
17528 return resultobj;
17529 fail:
17530 return NULL;
17531 }
17532
17533
17534 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17535 PyObject *resultobj;
17536 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17537 bool result;
17538 PyObject * obj0 = 0 ;
17539 char *kwnames[] = {
17540 (char *) "self", NULL
17541 };
17542
17543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17545 if (SWIG_arg_fail(1)) SWIG_fail;
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17549
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 {
17554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17555 }
17556 return resultobj;
17557 fail:
17558 return NULL;
17559 }
17560
17561
17562 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17563 PyObject *resultobj;
17564 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17565 bool result;
17566 PyObject * obj0 = 0 ;
17567 char *kwnames[] = {
17568 (char *) "self", NULL
17569 };
17570
17571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17573 if (SWIG_arg_fail(1)) SWIG_fail;
17574 {
17575 PyThreadState* __tstate = wxPyBeginAllowThreads();
17576 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17577
17578 wxPyEndAllowThreads(__tstate);
17579 if (PyErr_Occurred()) SWIG_fail;
17580 }
17581 {
17582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17583 }
17584 return resultobj;
17585 fail:
17586 return NULL;
17587 }
17588
17589
17590 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17591 PyObject *resultobj;
17592 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17593 bool result;
17594 PyObject * obj0 = 0 ;
17595 char *kwnames[] = {
17596 (char *) "self", NULL
17597 };
17598
17599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17601 if (SWIG_arg_fail(1)) SWIG_fail;
17602 {
17603 PyThreadState* __tstate = wxPyBeginAllowThreads();
17604 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17605
17606 wxPyEndAllowThreads(__tstate);
17607 if (PyErr_Occurred()) SWIG_fail;
17608 }
17609 {
17610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17611 }
17612 return resultobj;
17613 fail:
17614 return NULL;
17615 }
17616
17617
17618 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17619 PyObject *resultobj;
17620 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17621 bool result;
17622 PyObject * obj0 = 0 ;
17623 char *kwnames[] = {
17624 (char *) "self", NULL
17625 };
17626
17627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17629 if (SWIG_arg_fail(1)) SWIG_fail;
17630 {
17631 PyThreadState* __tstate = wxPyBeginAllowThreads();
17632 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17633
17634 wxPyEndAllowThreads(__tstate);
17635 if (PyErr_Occurred()) SWIG_fail;
17636 }
17637 {
17638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17639 }
17640 return resultobj;
17641 fail:
17642 return NULL;
17643 }
17644
17645
17646 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17647 PyObject *resultobj;
17648 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17649 bool result;
17650 PyObject * obj0 = 0 ;
17651 char *kwnames[] = {
17652 (char *) "self", NULL
17653 };
17654
17655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17657 if (SWIG_arg_fail(1)) SWIG_fail;
17658 {
17659 PyThreadState* __tstate = wxPyBeginAllowThreads();
17660 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17661
17662 wxPyEndAllowThreads(__tstate);
17663 if (PyErr_Occurred()) SWIG_fail;
17664 }
17665 {
17666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17667 }
17668 return resultobj;
17669 fail:
17670 return NULL;
17671 }
17672
17673
17674 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17675 PyObject *resultobj;
17676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17677 bool result;
17678 PyObject * obj0 = 0 ;
17679 char *kwnames[] = {
17680 (char *) "self", NULL
17681 };
17682
17683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17685 if (SWIG_arg_fail(1)) SWIG_fail;
17686 {
17687 PyThreadState* __tstate = wxPyBeginAllowThreads();
17688 result = (bool)(arg1)->LeftIsDown();
17689
17690 wxPyEndAllowThreads(__tstate);
17691 if (PyErr_Occurred()) SWIG_fail;
17692 }
17693 {
17694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17695 }
17696 return resultobj;
17697 fail:
17698 return NULL;
17699 }
17700
17701
17702 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17703 PyObject *resultobj;
17704 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17705 bool result;
17706 PyObject * obj0 = 0 ;
17707 char *kwnames[] = {
17708 (char *) "self", NULL
17709 };
17710
17711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17713 if (SWIG_arg_fail(1)) SWIG_fail;
17714 {
17715 PyThreadState* __tstate = wxPyBeginAllowThreads();
17716 result = (bool)(arg1)->MiddleIsDown();
17717
17718 wxPyEndAllowThreads(__tstate);
17719 if (PyErr_Occurred()) SWIG_fail;
17720 }
17721 {
17722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17723 }
17724 return resultobj;
17725 fail:
17726 return NULL;
17727 }
17728
17729
17730 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17731 PyObject *resultobj;
17732 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17733 bool result;
17734 PyObject * obj0 = 0 ;
17735 char *kwnames[] = {
17736 (char *) "self", NULL
17737 };
17738
17739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17741 if (SWIG_arg_fail(1)) SWIG_fail;
17742 {
17743 PyThreadState* __tstate = wxPyBeginAllowThreads();
17744 result = (bool)(arg1)->RightIsDown();
17745
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 {
17750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17751 }
17752 return resultobj;
17753 fail:
17754 return NULL;
17755 }
17756
17757
17758 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17759 PyObject *resultobj;
17760 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17761 bool result;
17762 PyObject * obj0 = 0 ;
17763 char *kwnames[] = {
17764 (char *) "self", NULL
17765 };
17766
17767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17769 if (SWIG_arg_fail(1)) SWIG_fail;
17770 {
17771 PyThreadState* __tstate = wxPyBeginAllowThreads();
17772 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17773
17774 wxPyEndAllowThreads(__tstate);
17775 if (PyErr_Occurred()) SWIG_fail;
17776 }
17777 {
17778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17779 }
17780 return resultobj;
17781 fail:
17782 return NULL;
17783 }
17784
17785
17786 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17787 PyObject *resultobj;
17788 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17789 bool result;
17790 PyObject * obj0 = 0 ;
17791 char *kwnames[] = {
17792 (char *) "self", NULL
17793 };
17794
17795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17797 if (SWIG_arg_fail(1)) SWIG_fail;
17798 {
17799 PyThreadState* __tstate = wxPyBeginAllowThreads();
17800 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17801
17802 wxPyEndAllowThreads(__tstate);
17803 if (PyErr_Occurred()) SWIG_fail;
17804 }
17805 {
17806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17807 }
17808 return resultobj;
17809 fail:
17810 return NULL;
17811 }
17812
17813
17814 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17815 PyObject *resultobj;
17816 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17817 bool result;
17818 PyObject * obj0 = 0 ;
17819 char *kwnames[] = {
17820 (char *) "self", NULL
17821 };
17822
17823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17825 if (SWIG_arg_fail(1)) SWIG_fail;
17826 {
17827 PyThreadState* __tstate = wxPyBeginAllowThreads();
17828 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17829
17830 wxPyEndAllowThreads(__tstate);
17831 if (PyErr_Occurred()) SWIG_fail;
17832 }
17833 {
17834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17835 }
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17843 PyObject *resultobj;
17844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17845 bool result;
17846 PyObject * obj0 = 0 ;
17847 char *kwnames[] = {
17848 (char *) "self", NULL
17849 };
17850
17851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17853 if (SWIG_arg_fail(1)) SWIG_fail;
17854 {
17855 PyThreadState* __tstate = wxPyBeginAllowThreads();
17856 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17857
17858 wxPyEndAllowThreads(__tstate);
17859 if (PyErr_Occurred()) SWIG_fail;
17860 }
17861 {
17862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17863 }
17864 return resultobj;
17865 fail:
17866 return NULL;
17867 }
17868
17869
17870 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17871 PyObject *resultobj;
17872 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17873 wxPoint result;
17874 PyObject * obj0 = 0 ;
17875 char *kwnames[] = {
17876 (char *) "self", NULL
17877 };
17878
17879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17881 if (SWIG_arg_fail(1)) SWIG_fail;
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 result = (arg1)->GetPosition();
17885
17886 wxPyEndAllowThreads(__tstate);
17887 if (PyErr_Occurred()) SWIG_fail;
17888 }
17889 {
17890 wxPoint * resultptr;
17891 resultptr = new wxPoint((wxPoint &)(result));
17892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17893 }
17894 return resultobj;
17895 fail:
17896 return NULL;
17897 }
17898
17899
17900 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17901 PyObject *resultobj;
17902 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17903 long *arg2 = (long *) 0 ;
17904 long *arg3 = (long *) 0 ;
17905 long temp2 ;
17906 int res2 = 0 ;
17907 long temp3 ;
17908 int res3 = 0 ;
17909 PyObject * obj0 = 0 ;
17910 char *kwnames[] = {
17911 (char *) "self", NULL
17912 };
17913
17914 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17915 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17918 if (SWIG_arg_fail(1)) SWIG_fail;
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 (arg1)->GetPosition(arg2,arg3);
17922
17923 wxPyEndAllowThreads(__tstate);
17924 if (PyErr_Occurred()) SWIG_fail;
17925 }
17926 Py_INCREF(Py_None); resultobj = Py_None;
17927 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17928 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17929 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17930 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17931 return resultobj;
17932 fail:
17933 return NULL;
17934 }
17935
17936
17937 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17938 PyObject *resultobj;
17939 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17940 wxDC *arg2 = 0 ;
17941 wxPoint result;
17942 PyObject * obj0 = 0 ;
17943 PyObject * obj1 = 0 ;
17944 char *kwnames[] = {
17945 (char *) "self",(char *) "dc", NULL
17946 };
17947
17948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17950 if (SWIG_arg_fail(1)) SWIG_fail;
17951 {
17952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17953 if (SWIG_arg_fail(2)) SWIG_fail;
17954 if (arg2 == NULL) {
17955 SWIG_null_ref("wxDC");
17956 }
17957 if (SWIG_arg_fail(2)) SWIG_fail;
17958 }
17959 {
17960 PyThreadState* __tstate = wxPyBeginAllowThreads();
17961 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17962
17963 wxPyEndAllowThreads(__tstate);
17964 if (PyErr_Occurred()) SWIG_fail;
17965 }
17966 {
17967 wxPoint * resultptr;
17968 resultptr = new wxPoint((wxPoint &)(result));
17969 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17970 }
17971 return resultobj;
17972 fail:
17973 return NULL;
17974 }
17975
17976
17977 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17978 PyObject *resultobj;
17979 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17980 int result;
17981 PyObject * obj0 = 0 ;
17982 char *kwnames[] = {
17983 (char *) "self", NULL
17984 };
17985
17986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17988 if (SWIG_arg_fail(1)) SWIG_fail;
17989 {
17990 PyThreadState* __tstate = wxPyBeginAllowThreads();
17991 result = (int)((wxMouseEvent const *)arg1)->GetX();
17992
17993 wxPyEndAllowThreads(__tstate);
17994 if (PyErr_Occurred()) SWIG_fail;
17995 }
17996 {
17997 resultobj = SWIG_From_int((int)(result));
17998 }
17999 return resultobj;
18000 fail:
18001 return NULL;
18002 }
18003
18004
18005 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18006 PyObject *resultobj;
18007 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18008 int result;
18009 PyObject * obj0 = 0 ;
18010 char *kwnames[] = {
18011 (char *) "self", NULL
18012 };
18013
18014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
18015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18016 if (SWIG_arg_fail(1)) SWIG_fail;
18017 {
18018 PyThreadState* __tstate = wxPyBeginAllowThreads();
18019 result = (int)((wxMouseEvent const *)arg1)->GetY();
18020
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 {
18025 resultobj = SWIG_From_int((int)(result));
18026 }
18027 return resultobj;
18028 fail:
18029 return NULL;
18030 }
18031
18032
18033 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18034 PyObject *resultobj;
18035 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18036 int result;
18037 PyObject * obj0 = 0 ;
18038 char *kwnames[] = {
18039 (char *) "self", NULL
18040 };
18041
18042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18044 if (SWIG_arg_fail(1)) SWIG_fail;
18045 {
18046 PyThreadState* __tstate = wxPyBeginAllowThreads();
18047 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18048
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 {
18053 resultobj = SWIG_From_int((int)(result));
18054 }
18055 return resultobj;
18056 fail:
18057 return NULL;
18058 }
18059
18060
18061 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18062 PyObject *resultobj;
18063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18064 int result;
18065 PyObject * obj0 = 0 ;
18066 char *kwnames[] = {
18067 (char *) "self", NULL
18068 };
18069
18070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18072 if (SWIG_arg_fail(1)) SWIG_fail;
18073 {
18074 PyThreadState* __tstate = wxPyBeginAllowThreads();
18075 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18076
18077 wxPyEndAllowThreads(__tstate);
18078 if (PyErr_Occurred()) SWIG_fail;
18079 }
18080 {
18081 resultobj = SWIG_From_int((int)(result));
18082 }
18083 return resultobj;
18084 fail:
18085 return NULL;
18086 }
18087
18088
18089 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18090 PyObject *resultobj;
18091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18092 int result;
18093 PyObject * obj0 = 0 ;
18094 char *kwnames[] = {
18095 (char *) "self", NULL
18096 };
18097
18098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18100 if (SWIG_arg_fail(1)) SWIG_fail;
18101 {
18102 PyThreadState* __tstate = wxPyBeginAllowThreads();
18103 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18104
18105 wxPyEndAllowThreads(__tstate);
18106 if (PyErr_Occurred()) SWIG_fail;
18107 }
18108 {
18109 resultobj = SWIG_From_int((int)(result));
18110 }
18111 return resultobj;
18112 fail:
18113 return NULL;
18114 }
18115
18116
18117 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18118 PyObject *resultobj;
18119 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18120 bool result;
18121 PyObject * obj0 = 0 ;
18122 char *kwnames[] = {
18123 (char *) "self", NULL
18124 };
18125
18126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18128 if (SWIG_arg_fail(1)) SWIG_fail;
18129 {
18130 PyThreadState* __tstate = wxPyBeginAllowThreads();
18131 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18132
18133 wxPyEndAllowThreads(__tstate);
18134 if (PyErr_Occurred()) SWIG_fail;
18135 }
18136 {
18137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18138 }
18139 return resultobj;
18140 fail:
18141 return NULL;
18142 }
18143
18144
18145 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18146 PyObject *resultobj;
18147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18148 int arg2 ;
18149 PyObject * obj0 = 0 ;
18150 PyObject * obj1 = 0 ;
18151 char *kwnames[] = {
18152 (char *) "self",(char *) "m_x", NULL
18153 };
18154
18155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18157 if (SWIG_arg_fail(1)) SWIG_fail;
18158 {
18159 arg2 = (int)(SWIG_As_int(obj1));
18160 if (SWIG_arg_fail(2)) SWIG_fail;
18161 }
18162 if (arg1) (arg1)->m_x = arg2;
18163
18164 Py_INCREF(Py_None); resultobj = Py_None;
18165 return resultobj;
18166 fail:
18167 return NULL;
18168 }
18169
18170
18171 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18172 PyObject *resultobj;
18173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18174 int result;
18175 PyObject * obj0 = 0 ;
18176 char *kwnames[] = {
18177 (char *) "self", NULL
18178 };
18179
18180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18182 if (SWIG_arg_fail(1)) SWIG_fail;
18183 result = (int) ((arg1)->m_x);
18184
18185 {
18186 resultobj = SWIG_From_int((int)(result));
18187 }
18188 return resultobj;
18189 fail:
18190 return NULL;
18191 }
18192
18193
18194 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18195 PyObject *resultobj;
18196 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18197 int arg2 ;
18198 PyObject * obj0 = 0 ;
18199 PyObject * obj1 = 0 ;
18200 char *kwnames[] = {
18201 (char *) "self",(char *) "m_y", NULL
18202 };
18203
18204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18206 if (SWIG_arg_fail(1)) SWIG_fail;
18207 {
18208 arg2 = (int)(SWIG_As_int(obj1));
18209 if (SWIG_arg_fail(2)) SWIG_fail;
18210 }
18211 if (arg1) (arg1)->m_y = arg2;
18212
18213 Py_INCREF(Py_None); resultobj = Py_None;
18214 return resultobj;
18215 fail:
18216 return NULL;
18217 }
18218
18219
18220 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18221 PyObject *resultobj;
18222 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18223 int result;
18224 PyObject * obj0 = 0 ;
18225 char *kwnames[] = {
18226 (char *) "self", NULL
18227 };
18228
18229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18231 if (SWIG_arg_fail(1)) SWIG_fail;
18232 result = (int) ((arg1)->m_y);
18233
18234 {
18235 resultobj = SWIG_From_int((int)(result));
18236 }
18237 return resultobj;
18238 fail:
18239 return NULL;
18240 }
18241
18242
18243 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18244 PyObject *resultobj;
18245 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18246 bool arg2 ;
18247 PyObject * obj0 = 0 ;
18248 PyObject * obj1 = 0 ;
18249 char *kwnames[] = {
18250 (char *) "self",(char *) "m_leftDown", NULL
18251 };
18252
18253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18255 if (SWIG_arg_fail(1)) SWIG_fail;
18256 {
18257 arg2 = (bool)(SWIG_As_bool(obj1));
18258 if (SWIG_arg_fail(2)) SWIG_fail;
18259 }
18260 if (arg1) (arg1)->m_leftDown = arg2;
18261
18262 Py_INCREF(Py_None); resultobj = Py_None;
18263 return resultobj;
18264 fail:
18265 return NULL;
18266 }
18267
18268
18269 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18270 PyObject *resultobj;
18271 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18272 bool result;
18273 PyObject * obj0 = 0 ;
18274 char *kwnames[] = {
18275 (char *) "self", NULL
18276 };
18277
18278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18280 if (SWIG_arg_fail(1)) SWIG_fail;
18281 result = (bool) ((arg1)->m_leftDown);
18282
18283 {
18284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18285 }
18286 return resultobj;
18287 fail:
18288 return NULL;
18289 }
18290
18291
18292 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18293 PyObject *resultobj;
18294 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18295 bool arg2 ;
18296 PyObject * obj0 = 0 ;
18297 PyObject * obj1 = 0 ;
18298 char *kwnames[] = {
18299 (char *) "self",(char *) "m_middleDown", NULL
18300 };
18301
18302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18304 if (SWIG_arg_fail(1)) SWIG_fail;
18305 {
18306 arg2 = (bool)(SWIG_As_bool(obj1));
18307 if (SWIG_arg_fail(2)) SWIG_fail;
18308 }
18309 if (arg1) (arg1)->m_middleDown = arg2;
18310
18311 Py_INCREF(Py_None); resultobj = Py_None;
18312 return resultobj;
18313 fail:
18314 return NULL;
18315 }
18316
18317
18318 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18319 PyObject *resultobj;
18320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18321 bool result;
18322 PyObject * obj0 = 0 ;
18323 char *kwnames[] = {
18324 (char *) "self", NULL
18325 };
18326
18327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18329 if (SWIG_arg_fail(1)) SWIG_fail;
18330 result = (bool) ((arg1)->m_middleDown);
18331
18332 {
18333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18334 }
18335 return resultobj;
18336 fail:
18337 return NULL;
18338 }
18339
18340
18341 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18342 PyObject *resultobj;
18343 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18344 bool arg2 ;
18345 PyObject * obj0 = 0 ;
18346 PyObject * obj1 = 0 ;
18347 char *kwnames[] = {
18348 (char *) "self",(char *) "m_rightDown", NULL
18349 };
18350
18351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18353 if (SWIG_arg_fail(1)) SWIG_fail;
18354 {
18355 arg2 = (bool)(SWIG_As_bool(obj1));
18356 if (SWIG_arg_fail(2)) SWIG_fail;
18357 }
18358 if (arg1) (arg1)->m_rightDown = arg2;
18359
18360 Py_INCREF(Py_None); resultobj = Py_None;
18361 return resultobj;
18362 fail:
18363 return NULL;
18364 }
18365
18366
18367 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18368 PyObject *resultobj;
18369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18370 bool result;
18371 PyObject * obj0 = 0 ;
18372 char *kwnames[] = {
18373 (char *) "self", NULL
18374 };
18375
18376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18378 if (SWIG_arg_fail(1)) SWIG_fail;
18379 result = (bool) ((arg1)->m_rightDown);
18380
18381 {
18382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18383 }
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18391 PyObject *resultobj;
18392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18393 bool arg2 ;
18394 PyObject * obj0 = 0 ;
18395 PyObject * obj1 = 0 ;
18396 char *kwnames[] = {
18397 (char *) "self",(char *) "m_controlDown", NULL
18398 };
18399
18400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18402 if (SWIG_arg_fail(1)) SWIG_fail;
18403 {
18404 arg2 = (bool)(SWIG_As_bool(obj1));
18405 if (SWIG_arg_fail(2)) SWIG_fail;
18406 }
18407 if (arg1) (arg1)->m_controlDown = arg2;
18408
18409 Py_INCREF(Py_None); resultobj = Py_None;
18410 return resultobj;
18411 fail:
18412 return NULL;
18413 }
18414
18415
18416 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18417 PyObject *resultobj;
18418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18419 bool result;
18420 PyObject * obj0 = 0 ;
18421 char *kwnames[] = {
18422 (char *) "self", NULL
18423 };
18424
18425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18427 if (SWIG_arg_fail(1)) SWIG_fail;
18428 result = (bool) ((arg1)->m_controlDown);
18429
18430 {
18431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18432 }
18433 return resultobj;
18434 fail:
18435 return NULL;
18436 }
18437
18438
18439 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18440 PyObject *resultobj;
18441 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18442 bool arg2 ;
18443 PyObject * obj0 = 0 ;
18444 PyObject * obj1 = 0 ;
18445 char *kwnames[] = {
18446 (char *) "self",(char *) "m_shiftDown", NULL
18447 };
18448
18449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18451 if (SWIG_arg_fail(1)) SWIG_fail;
18452 {
18453 arg2 = (bool)(SWIG_As_bool(obj1));
18454 if (SWIG_arg_fail(2)) SWIG_fail;
18455 }
18456 if (arg1) (arg1)->m_shiftDown = arg2;
18457
18458 Py_INCREF(Py_None); resultobj = Py_None;
18459 return resultobj;
18460 fail:
18461 return NULL;
18462 }
18463
18464
18465 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18466 PyObject *resultobj;
18467 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18468 bool result;
18469 PyObject * obj0 = 0 ;
18470 char *kwnames[] = {
18471 (char *) "self", NULL
18472 };
18473
18474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18476 if (SWIG_arg_fail(1)) SWIG_fail;
18477 result = (bool) ((arg1)->m_shiftDown);
18478
18479 {
18480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18481 }
18482 return resultobj;
18483 fail:
18484 return NULL;
18485 }
18486
18487
18488 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18489 PyObject *resultobj;
18490 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18491 bool arg2 ;
18492 PyObject * obj0 = 0 ;
18493 PyObject * obj1 = 0 ;
18494 char *kwnames[] = {
18495 (char *) "self",(char *) "m_altDown", NULL
18496 };
18497
18498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18500 if (SWIG_arg_fail(1)) SWIG_fail;
18501 {
18502 arg2 = (bool)(SWIG_As_bool(obj1));
18503 if (SWIG_arg_fail(2)) SWIG_fail;
18504 }
18505 if (arg1) (arg1)->m_altDown = arg2;
18506
18507 Py_INCREF(Py_None); resultobj = Py_None;
18508 return resultobj;
18509 fail:
18510 return NULL;
18511 }
18512
18513
18514 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18515 PyObject *resultobj;
18516 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18517 bool result;
18518 PyObject * obj0 = 0 ;
18519 char *kwnames[] = {
18520 (char *) "self", NULL
18521 };
18522
18523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18525 if (SWIG_arg_fail(1)) SWIG_fail;
18526 result = (bool) ((arg1)->m_altDown);
18527
18528 {
18529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18530 }
18531 return resultobj;
18532 fail:
18533 return NULL;
18534 }
18535
18536
18537 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18538 PyObject *resultobj;
18539 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18540 bool arg2 ;
18541 PyObject * obj0 = 0 ;
18542 PyObject * obj1 = 0 ;
18543 char *kwnames[] = {
18544 (char *) "self",(char *) "m_metaDown", NULL
18545 };
18546
18547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18549 if (SWIG_arg_fail(1)) SWIG_fail;
18550 {
18551 arg2 = (bool)(SWIG_As_bool(obj1));
18552 if (SWIG_arg_fail(2)) SWIG_fail;
18553 }
18554 if (arg1) (arg1)->m_metaDown = arg2;
18555
18556 Py_INCREF(Py_None); resultobj = Py_None;
18557 return resultobj;
18558 fail:
18559 return NULL;
18560 }
18561
18562
18563 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18564 PyObject *resultobj;
18565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18566 bool result;
18567 PyObject * obj0 = 0 ;
18568 char *kwnames[] = {
18569 (char *) "self", NULL
18570 };
18571
18572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18574 if (SWIG_arg_fail(1)) SWIG_fail;
18575 result = (bool) ((arg1)->m_metaDown);
18576
18577 {
18578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18579 }
18580 return resultobj;
18581 fail:
18582 return NULL;
18583 }
18584
18585
18586 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18587 PyObject *resultobj;
18588 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18589 int arg2 ;
18590 PyObject * obj0 = 0 ;
18591 PyObject * obj1 = 0 ;
18592 char *kwnames[] = {
18593 (char *) "self",(char *) "m_wheelRotation", NULL
18594 };
18595
18596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18598 if (SWIG_arg_fail(1)) SWIG_fail;
18599 {
18600 arg2 = (int)(SWIG_As_int(obj1));
18601 if (SWIG_arg_fail(2)) SWIG_fail;
18602 }
18603 if (arg1) (arg1)->m_wheelRotation = arg2;
18604
18605 Py_INCREF(Py_None); resultobj = Py_None;
18606 return resultobj;
18607 fail:
18608 return NULL;
18609 }
18610
18611
18612 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18613 PyObject *resultobj;
18614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18615 int result;
18616 PyObject * obj0 = 0 ;
18617 char *kwnames[] = {
18618 (char *) "self", NULL
18619 };
18620
18621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18623 if (SWIG_arg_fail(1)) SWIG_fail;
18624 result = (int) ((arg1)->m_wheelRotation);
18625
18626 {
18627 resultobj = SWIG_From_int((int)(result));
18628 }
18629 return resultobj;
18630 fail:
18631 return NULL;
18632 }
18633
18634
18635 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18636 PyObject *resultobj;
18637 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18638 int arg2 ;
18639 PyObject * obj0 = 0 ;
18640 PyObject * obj1 = 0 ;
18641 char *kwnames[] = {
18642 (char *) "self",(char *) "m_wheelDelta", NULL
18643 };
18644
18645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18647 if (SWIG_arg_fail(1)) SWIG_fail;
18648 {
18649 arg2 = (int)(SWIG_As_int(obj1));
18650 if (SWIG_arg_fail(2)) SWIG_fail;
18651 }
18652 if (arg1) (arg1)->m_wheelDelta = arg2;
18653
18654 Py_INCREF(Py_None); resultobj = Py_None;
18655 return resultobj;
18656 fail:
18657 return NULL;
18658 }
18659
18660
18661 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18662 PyObject *resultobj;
18663 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18664 int result;
18665 PyObject * obj0 = 0 ;
18666 char *kwnames[] = {
18667 (char *) "self", NULL
18668 };
18669
18670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18672 if (SWIG_arg_fail(1)) SWIG_fail;
18673 result = (int) ((arg1)->m_wheelDelta);
18674
18675 {
18676 resultobj = SWIG_From_int((int)(result));
18677 }
18678 return resultobj;
18679 fail:
18680 return NULL;
18681 }
18682
18683
18684 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18685 PyObject *resultobj;
18686 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18687 int arg2 ;
18688 PyObject * obj0 = 0 ;
18689 PyObject * obj1 = 0 ;
18690 char *kwnames[] = {
18691 (char *) "self",(char *) "m_linesPerAction", NULL
18692 };
18693
18694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18696 if (SWIG_arg_fail(1)) SWIG_fail;
18697 {
18698 arg2 = (int)(SWIG_As_int(obj1));
18699 if (SWIG_arg_fail(2)) SWIG_fail;
18700 }
18701 if (arg1) (arg1)->m_linesPerAction = arg2;
18702
18703 Py_INCREF(Py_None); resultobj = Py_None;
18704 return resultobj;
18705 fail:
18706 return NULL;
18707 }
18708
18709
18710 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18711 PyObject *resultobj;
18712 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18713 int result;
18714 PyObject * obj0 = 0 ;
18715 char *kwnames[] = {
18716 (char *) "self", NULL
18717 };
18718
18719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18721 if (SWIG_arg_fail(1)) SWIG_fail;
18722 result = (int) ((arg1)->m_linesPerAction);
18723
18724 {
18725 resultobj = SWIG_From_int((int)(result));
18726 }
18727 return resultobj;
18728 fail:
18729 return NULL;
18730 }
18731
18732
18733 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18734 PyObject *obj;
18735 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18736 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18737 Py_INCREF(obj);
18738 return Py_BuildValue((char *)"");
18739 }
18740 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18741 PyObject *resultobj;
18742 int arg1 = (int) 0 ;
18743 int arg2 = (int) 0 ;
18744 wxSetCursorEvent *result;
18745 PyObject * obj0 = 0 ;
18746 PyObject * obj1 = 0 ;
18747 char *kwnames[] = {
18748 (char *) "x",(char *) "y", NULL
18749 };
18750
18751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18752 if (obj0) {
18753 {
18754 arg1 = (int)(SWIG_As_int(obj0));
18755 if (SWIG_arg_fail(1)) SWIG_fail;
18756 }
18757 }
18758 if (obj1) {
18759 {
18760 arg2 = (int)(SWIG_As_int(obj1));
18761 if (SWIG_arg_fail(2)) SWIG_fail;
18762 }
18763 }
18764 {
18765 PyThreadState* __tstate = wxPyBeginAllowThreads();
18766 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18767
18768 wxPyEndAllowThreads(__tstate);
18769 if (PyErr_Occurred()) SWIG_fail;
18770 }
18771 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18772 return resultobj;
18773 fail:
18774 return NULL;
18775 }
18776
18777
18778 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18779 PyObject *resultobj;
18780 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 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:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18789 if (SWIG_arg_fail(1)) SWIG_fail;
18790 {
18791 PyThreadState* __tstate = wxPyBeginAllowThreads();
18792 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18793
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 {
18798 resultobj = SWIG_From_int((int)(result));
18799 }
18800 return resultobj;
18801 fail:
18802 return NULL;
18803 }
18804
18805
18806 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18807 PyObject *resultobj;
18808 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18809 int result;
18810 PyObject * obj0 = 0 ;
18811 char *kwnames[] = {
18812 (char *) "self", NULL
18813 };
18814
18815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18817 if (SWIG_arg_fail(1)) SWIG_fail;
18818 {
18819 PyThreadState* __tstate = wxPyBeginAllowThreads();
18820 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18821
18822 wxPyEndAllowThreads(__tstate);
18823 if (PyErr_Occurred()) SWIG_fail;
18824 }
18825 {
18826 resultobj = SWIG_From_int((int)(result));
18827 }
18828 return resultobj;
18829 fail:
18830 return NULL;
18831 }
18832
18833
18834 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18835 PyObject *resultobj;
18836 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18837 wxCursor *arg2 = 0 ;
18838 PyObject * obj0 = 0 ;
18839 PyObject * obj1 = 0 ;
18840 char *kwnames[] = {
18841 (char *) "self",(char *) "cursor", NULL
18842 };
18843
18844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18846 if (SWIG_arg_fail(1)) SWIG_fail;
18847 {
18848 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18849 if (SWIG_arg_fail(2)) SWIG_fail;
18850 if (arg2 == NULL) {
18851 SWIG_null_ref("wxCursor");
18852 }
18853 if (SWIG_arg_fail(2)) SWIG_fail;
18854 }
18855 {
18856 PyThreadState* __tstate = wxPyBeginAllowThreads();
18857 (arg1)->SetCursor((wxCursor const &)*arg2);
18858
18859 wxPyEndAllowThreads(__tstate);
18860 if (PyErr_Occurred()) SWIG_fail;
18861 }
18862 Py_INCREF(Py_None); resultobj = Py_None;
18863 return resultobj;
18864 fail:
18865 return NULL;
18866 }
18867
18868
18869 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18870 PyObject *resultobj;
18871 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18872 wxCursor *result;
18873 PyObject * obj0 = 0 ;
18874 char *kwnames[] = {
18875 (char *) "self", NULL
18876 };
18877
18878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18880 if (SWIG_arg_fail(1)) SWIG_fail;
18881 {
18882 PyThreadState* __tstate = wxPyBeginAllowThreads();
18883 {
18884 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18885 result = (wxCursor *) &_result_ref;
18886 }
18887
18888 wxPyEndAllowThreads(__tstate);
18889 if (PyErr_Occurred()) SWIG_fail;
18890 }
18891 {
18892 wxCursor* resultptr = new wxCursor(*result);
18893 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18894 }
18895 return resultobj;
18896 fail:
18897 return NULL;
18898 }
18899
18900
18901 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18902 PyObject *resultobj;
18903 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18904 bool result;
18905 PyObject * obj0 = 0 ;
18906 char *kwnames[] = {
18907 (char *) "self", NULL
18908 };
18909
18910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18912 if (SWIG_arg_fail(1)) SWIG_fail;
18913 {
18914 PyThreadState* __tstate = wxPyBeginAllowThreads();
18915 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18916
18917 wxPyEndAllowThreads(__tstate);
18918 if (PyErr_Occurred()) SWIG_fail;
18919 }
18920 {
18921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18922 }
18923 return resultobj;
18924 fail:
18925 return NULL;
18926 }
18927
18928
18929 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18930 PyObject *obj;
18931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18932 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18933 Py_INCREF(obj);
18934 return Py_BuildValue((char *)"");
18935 }
18936 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18937 PyObject *resultobj;
18938 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18939 wxKeyEvent *result;
18940 PyObject * obj0 = 0 ;
18941 char *kwnames[] = {
18942 (char *) "eventType", NULL
18943 };
18944
18945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18946 if (obj0) {
18947 {
18948 arg1 = (wxEventType)(SWIG_As_int(obj0));
18949 if (SWIG_arg_fail(1)) SWIG_fail;
18950 }
18951 }
18952 {
18953 PyThreadState* __tstate = wxPyBeginAllowThreads();
18954 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18955
18956 wxPyEndAllowThreads(__tstate);
18957 if (PyErr_Occurred()) SWIG_fail;
18958 }
18959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18960 return resultobj;
18961 fail:
18962 return NULL;
18963 }
18964
18965
18966 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18967 PyObject *resultobj;
18968 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18969 bool result;
18970 PyObject * obj0 = 0 ;
18971 char *kwnames[] = {
18972 (char *) "self", NULL
18973 };
18974
18975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18977 if (SWIG_arg_fail(1)) SWIG_fail;
18978 {
18979 PyThreadState* __tstate = wxPyBeginAllowThreads();
18980 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18981
18982 wxPyEndAllowThreads(__tstate);
18983 if (PyErr_Occurred()) SWIG_fail;
18984 }
18985 {
18986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18987 }
18988 return resultobj;
18989 fail:
18990 return NULL;
18991 }
18992
18993
18994 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18995 PyObject *resultobj;
18996 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18997 bool result;
18998 PyObject * obj0 = 0 ;
18999 char *kwnames[] = {
19000 (char *) "self", NULL
19001 };
19002
19003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
19004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19005 if (SWIG_arg_fail(1)) SWIG_fail;
19006 {
19007 PyThreadState* __tstate = wxPyBeginAllowThreads();
19008 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
19009
19010 wxPyEndAllowThreads(__tstate);
19011 if (PyErr_Occurred()) SWIG_fail;
19012 }
19013 {
19014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19015 }
19016 return resultobj;
19017 fail:
19018 return NULL;
19019 }
19020
19021
19022 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
19023 PyObject *resultobj;
19024 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19025 bool result;
19026 PyObject * obj0 = 0 ;
19027 char *kwnames[] = {
19028 (char *) "self", NULL
19029 };
19030
19031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19033 if (SWIG_arg_fail(1)) SWIG_fail;
19034 {
19035 PyThreadState* __tstate = wxPyBeginAllowThreads();
19036 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19037
19038 wxPyEndAllowThreads(__tstate);
19039 if (PyErr_Occurred()) SWIG_fail;
19040 }
19041 {
19042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19043 }
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19051 PyObject *resultobj;
19052 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19053 bool result;
19054 PyObject * obj0 = 0 ;
19055 char *kwnames[] = {
19056 (char *) "self", NULL
19057 };
19058
19059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19061 if (SWIG_arg_fail(1)) SWIG_fail;
19062 {
19063 PyThreadState* __tstate = wxPyBeginAllowThreads();
19064 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19065
19066 wxPyEndAllowThreads(__tstate);
19067 if (PyErr_Occurred()) SWIG_fail;
19068 }
19069 {
19070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19071 }
19072 return resultobj;
19073 fail:
19074 return NULL;
19075 }
19076
19077
19078 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19079 PyObject *resultobj;
19080 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19081 bool result;
19082 PyObject * obj0 = 0 ;
19083 char *kwnames[] = {
19084 (char *) "self", NULL
19085 };
19086
19087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19089 if (SWIG_arg_fail(1)) SWIG_fail;
19090 {
19091 PyThreadState* __tstate = wxPyBeginAllowThreads();
19092 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19093
19094 wxPyEndAllowThreads(__tstate);
19095 if (PyErr_Occurred()) SWIG_fail;
19096 }
19097 {
19098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19099 }
19100 return resultobj;
19101 fail:
19102 return NULL;
19103 }
19104
19105
19106 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj;
19108 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19109 bool result;
19110 PyObject * obj0 = 0 ;
19111 char *kwnames[] = {
19112 (char *) "self", NULL
19113 };
19114
19115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19117 if (SWIG_arg_fail(1)) SWIG_fail;
19118 {
19119 PyThreadState* __tstate = wxPyBeginAllowThreads();
19120 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19121
19122 wxPyEndAllowThreads(__tstate);
19123 if (PyErr_Occurred()) SWIG_fail;
19124 }
19125 {
19126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19127 }
19128 return resultobj;
19129 fail:
19130 return NULL;
19131 }
19132
19133
19134 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19135 PyObject *resultobj;
19136 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19137 int result;
19138 PyObject * obj0 = 0 ;
19139 char *kwnames[] = {
19140 (char *) "self", NULL
19141 };
19142
19143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19145 if (SWIG_arg_fail(1)) SWIG_fail;
19146 {
19147 PyThreadState* __tstate = wxPyBeginAllowThreads();
19148 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19149
19150 wxPyEndAllowThreads(__tstate);
19151 if (PyErr_Occurred()) SWIG_fail;
19152 }
19153 {
19154 resultobj = SWIG_From_int((int)(result));
19155 }
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj;
19164 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19165 int result;
19166 PyObject * obj0 = 0 ;
19167 char *kwnames[] = {
19168 (char *) "self", NULL
19169 };
19170
19171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19173 if (SWIG_arg_fail(1)) SWIG_fail;
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19177
19178 wxPyEndAllowThreads(__tstate);
19179 if (PyErr_Occurred()) SWIG_fail;
19180 }
19181 {
19182 resultobj = SWIG_From_int((int)(result));
19183 }
19184 return resultobj;
19185 fail:
19186 return NULL;
19187 }
19188
19189
19190 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19191 PyObject *resultobj;
19192 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19193 unsigned int result;
19194 PyObject * obj0 = 0 ;
19195 char *kwnames[] = {
19196 (char *) "self", NULL
19197 };
19198
19199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19201 if (SWIG_arg_fail(1)) SWIG_fail;
19202 {
19203 PyThreadState* __tstate = wxPyBeginAllowThreads();
19204 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19205
19206 wxPyEndAllowThreads(__tstate);
19207 if (PyErr_Occurred()) SWIG_fail;
19208 }
19209 {
19210 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19211 }
19212 return resultobj;
19213 fail:
19214 return NULL;
19215 }
19216
19217
19218 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19219 PyObject *resultobj;
19220 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19221 unsigned int result;
19222 PyObject * obj0 = 0 ;
19223 char *kwnames[] = {
19224 (char *) "self", NULL
19225 };
19226
19227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19229 if (SWIG_arg_fail(1)) SWIG_fail;
19230 {
19231 PyThreadState* __tstate = wxPyBeginAllowThreads();
19232 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19233
19234 wxPyEndAllowThreads(__tstate);
19235 if (PyErr_Occurred()) SWIG_fail;
19236 }
19237 {
19238 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19239 }
19240 return resultobj;
19241 fail:
19242 return NULL;
19243 }
19244
19245
19246 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19247 PyObject *resultobj;
19248 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19249 wxPoint result;
19250 PyObject * obj0 = 0 ;
19251 char *kwnames[] = {
19252 (char *) "self", NULL
19253 };
19254
19255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19257 if (SWIG_arg_fail(1)) SWIG_fail;
19258 {
19259 PyThreadState* __tstate = wxPyBeginAllowThreads();
19260 result = (arg1)->GetPosition();
19261
19262 wxPyEndAllowThreads(__tstate);
19263 if (PyErr_Occurred()) SWIG_fail;
19264 }
19265 {
19266 wxPoint * resultptr;
19267 resultptr = new wxPoint((wxPoint &)(result));
19268 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19269 }
19270 return resultobj;
19271 fail:
19272 return NULL;
19273 }
19274
19275
19276 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19277 PyObject *resultobj;
19278 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19279 long *arg2 = (long *) 0 ;
19280 long *arg3 = (long *) 0 ;
19281 long temp2 ;
19282 int res2 = 0 ;
19283 long temp3 ;
19284 int res3 = 0 ;
19285 PyObject * obj0 = 0 ;
19286 char *kwnames[] = {
19287 (char *) "self", NULL
19288 };
19289
19290 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19291 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19294 if (SWIG_arg_fail(1)) SWIG_fail;
19295 {
19296 PyThreadState* __tstate = wxPyBeginAllowThreads();
19297 (arg1)->GetPosition(arg2,arg3);
19298
19299 wxPyEndAllowThreads(__tstate);
19300 if (PyErr_Occurred()) SWIG_fail;
19301 }
19302 Py_INCREF(Py_None); resultobj = Py_None;
19303 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19304 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19305 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19306 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19307 return resultobj;
19308 fail:
19309 return NULL;
19310 }
19311
19312
19313 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19314 PyObject *resultobj;
19315 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19316 int result;
19317 PyObject * obj0 = 0 ;
19318 char *kwnames[] = {
19319 (char *) "self", NULL
19320 };
19321
19322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19324 if (SWIG_arg_fail(1)) SWIG_fail;
19325 {
19326 PyThreadState* __tstate = wxPyBeginAllowThreads();
19327 result = (int)((wxKeyEvent const *)arg1)->GetX();
19328
19329 wxPyEndAllowThreads(__tstate);
19330 if (PyErr_Occurred()) SWIG_fail;
19331 }
19332 {
19333 resultobj = SWIG_From_int((int)(result));
19334 }
19335 return resultobj;
19336 fail:
19337 return NULL;
19338 }
19339
19340
19341 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19342 PyObject *resultobj;
19343 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19344 int result;
19345 PyObject * obj0 = 0 ;
19346 char *kwnames[] = {
19347 (char *) "self", NULL
19348 };
19349
19350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19352 if (SWIG_arg_fail(1)) SWIG_fail;
19353 {
19354 PyThreadState* __tstate = wxPyBeginAllowThreads();
19355 result = (int)((wxKeyEvent const *)arg1)->GetY();
19356
19357 wxPyEndAllowThreads(__tstate);
19358 if (PyErr_Occurred()) SWIG_fail;
19359 }
19360 {
19361 resultobj = SWIG_From_int((int)(result));
19362 }
19363 return resultobj;
19364 fail:
19365 return NULL;
19366 }
19367
19368
19369 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19370 PyObject *resultobj;
19371 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19372 int arg2 ;
19373 PyObject * obj0 = 0 ;
19374 PyObject * obj1 = 0 ;
19375 char *kwnames[] = {
19376 (char *) "self",(char *) "m_x", NULL
19377 };
19378
19379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19381 if (SWIG_arg_fail(1)) SWIG_fail;
19382 {
19383 arg2 = (int)(SWIG_As_int(obj1));
19384 if (SWIG_arg_fail(2)) SWIG_fail;
19385 }
19386 if (arg1) (arg1)->m_x = arg2;
19387
19388 Py_INCREF(Py_None); resultobj = Py_None;
19389 return resultobj;
19390 fail:
19391 return NULL;
19392 }
19393
19394
19395 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19396 PyObject *resultobj;
19397 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19398 int result;
19399 PyObject * obj0 = 0 ;
19400 char *kwnames[] = {
19401 (char *) "self", NULL
19402 };
19403
19404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19406 if (SWIG_arg_fail(1)) SWIG_fail;
19407 result = (int) ((arg1)->m_x);
19408
19409 {
19410 resultobj = SWIG_From_int((int)(result));
19411 }
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj;
19420 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19421 int arg2 ;
19422 PyObject * obj0 = 0 ;
19423 PyObject * obj1 = 0 ;
19424 char *kwnames[] = {
19425 (char *) "self",(char *) "m_y", NULL
19426 };
19427
19428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19430 if (SWIG_arg_fail(1)) SWIG_fail;
19431 {
19432 arg2 = (int)(SWIG_As_int(obj1));
19433 if (SWIG_arg_fail(2)) SWIG_fail;
19434 }
19435 if (arg1) (arg1)->m_y = arg2;
19436
19437 Py_INCREF(Py_None); resultobj = Py_None;
19438 return resultobj;
19439 fail:
19440 return NULL;
19441 }
19442
19443
19444 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19445 PyObject *resultobj;
19446 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19447 int result;
19448 PyObject * obj0 = 0 ;
19449 char *kwnames[] = {
19450 (char *) "self", NULL
19451 };
19452
19453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19455 if (SWIG_arg_fail(1)) SWIG_fail;
19456 result = (int) ((arg1)->m_y);
19457
19458 {
19459 resultobj = SWIG_From_int((int)(result));
19460 }
19461 return resultobj;
19462 fail:
19463 return NULL;
19464 }
19465
19466
19467 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19468 PyObject *resultobj;
19469 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19470 long arg2 ;
19471 PyObject * obj0 = 0 ;
19472 PyObject * obj1 = 0 ;
19473 char *kwnames[] = {
19474 (char *) "self",(char *) "m_keyCode", NULL
19475 };
19476
19477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19479 if (SWIG_arg_fail(1)) SWIG_fail;
19480 {
19481 arg2 = (long)(SWIG_As_long(obj1));
19482 if (SWIG_arg_fail(2)) SWIG_fail;
19483 }
19484 if (arg1) (arg1)->m_keyCode = arg2;
19485
19486 Py_INCREF(Py_None); resultobj = Py_None;
19487 return resultobj;
19488 fail:
19489 return NULL;
19490 }
19491
19492
19493 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19494 PyObject *resultobj;
19495 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19496 long result;
19497 PyObject * obj0 = 0 ;
19498 char *kwnames[] = {
19499 (char *) "self", NULL
19500 };
19501
19502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19504 if (SWIG_arg_fail(1)) SWIG_fail;
19505 result = (long) ((arg1)->m_keyCode);
19506
19507 {
19508 resultobj = SWIG_From_long((long)(result));
19509 }
19510 return resultobj;
19511 fail:
19512 return NULL;
19513 }
19514
19515
19516 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19517 PyObject *resultobj;
19518 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19519 bool arg2 ;
19520 PyObject * obj0 = 0 ;
19521 PyObject * obj1 = 0 ;
19522 char *kwnames[] = {
19523 (char *) "self",(char *) "m_controlDown", NULL
19524 };
19525
19526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19528 if (SWIG_arg_fail(1)) SWIG_fail;
19529 {
19530 arg2 = (bool)(SWIG_As_bool(obj1));
19531 if (SWIG_arg_fail(2)) SWIG_fail;
19532 }
19533 if (arg1) (arg1)->m_controlDown = arg2;
19534
19535 Py_INCREF(Py_None); resultobj = Py_None;
19536 return resultobj;
19537 fail:
19538 return NULL;
19539 }
19540
19541
19542 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19543 PyObject *resultobj;
19544 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19545 bool result;
19546 PyObject * obj0 = 0 ;
19547 char *kwnames[] = {
19548 (char *) "self", NULL
19549 };
19550
19551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19553 if (SWIG_arg_fail(1)) SWIG_fail;
19554 result = (bool) ((arg1)->m_controlDown);
19555
19556 {
19557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19558 }
19559 return resultobj;
19560 fail:
19561 return NULL;
19562 }
19563
19564
19565 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19566 PyObject *resultobj;
19567 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19568 bool arg2 ;
19569 PyObject * obj0 = 0 ;
19570 PyObject * obj1 = 0 ;
19571 char *kwnames[] = {
19572 (char *) "self",(char *) "m_shiftDown", NULL
19573 };
19574
19575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19577 if (SWIG_arg_fail(1)) SWIG_fail;
19578 {
19579 arg2 = (bool)(SWIG_As_bool(obj1));
19580 if (SWIG_arg_fail(2)) SWIG_fail;
19581 }
19582 if (arg1) (arg1)->m_shiftDown = arg2;
19583
19584 Py_INCREF(Py_None); resultobj = Py_None;
19585 return resultobj;
19586 fail:
19587 return NULL;
19588 }
19589
19590
19591 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19592 PyObject *resultobj;
19593 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19594 bool result;
19595 PyObject * obj0 = 0 ;
19596 char *kwnames[] = {
19597 (char *) "self", NULL
19598 };
19599
19600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19602 if (SWIG_arg_fail(1)) SWIG_fail;
19603 result = (bool) ((arg1)->m_shiftDown);
19604
19605 {
19606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19607 }
19608 return resultobj;
19609 fail:
19610 return NULL;
19611 }
19612
19613
19614 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19615 PyObject *resultobj;
19616 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19617 bool arg2 ;
19618 PyObject * obj0 = 0 ;
19619 PyObject * obj1 = 0 ;
19620 char *kwnames[] = {
19621 (char *) "self",(char *) "m_altDown", NULL
19622 };
19623
19624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19626 if (SWIG_arg_fail(1)) SWIG_fail;
19627 {
19628 arg2 = (bool)(SWIG_As_bool(obj1));
19629 if (SWIG_arg_fail(2)) SWIG_fail;
19630 }
19631 if (arg1) (arg1)->m_altDown = arg2;
19632
19633 Py_INCREF(Py_None); resultobj = Py_None;
19634 return resultobj;
19635 fail:
19636 return NULL;
19637 }
19638
19639
19640 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19641 PyObject *resultobj;
19642 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19643 bool result;
19644 PyObject * obj0 = 0 ;
19645 char *kwnames[] = {
19646 (char *) "self", NULL
19647 };
19648
19649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19651 if (SWIG_arg_fail(1)) SWIG_fail;
19652 result = (bool) ((arg1)->m_altDown);
19653
19654 {
19655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19656 }
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19664 PyObject *resultobj;
19665 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19666 bool arg2 ;
19667 PyObject * obj0 = 0 ;
19668 PyObject * obj1 = 0 ;
19669 char *kwnames[] = {
19670 (char *) "self",(char *) "m_metaDown", NULL
19671 };
19672
19673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19675 if (SWIG_arg_fail(1)) SWIG_fail;
19676 {
19677 arg2 = (bool)(SWIG_As_bool(obj1));
19678 if (SWIG_arg_fail(2)) SWIG_fail;
19679 }
19680 if (arg1) (arg1)->m_metaDown = arg2;
19681
19682 Py_INCREF(Py_None); resultobj = Py_None;
19683 return resultobj;
19684 fail:
19685 return NULL;
19686 }
19687
19688
19689 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19690 PyObject *resultobj;
19691 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19692 bool result;
19693 PyObject * obj0 = 0 ;
19694 char *kwnames[] = {
19695 (char *) "self", NULL
19696 };
19697
19698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19700 if (SWIG_arg_fail(1)) SWIG_fail;
19701 result = (bool) ((arg1)->m_metaDown);
19702
19703 {
19704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19705 }
19706 return resultobj;
19707 fail:
19708 return NULL;
19709 }
19710
19711
19712 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19713 PyObject *resultobj;
19714 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19715 bool arg2 ;
19716 PyObject * obj0 = 0 ;
19717 PyObject * obj1 = 0 ;
19718 char *kwnames[] = {
19719 (char *) "self",(char *) "m_scanCode", NULL
19720 };
19721
19722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19724 if (SWIG_arg_fail(1)) SWIG_fail;
19725 {
19726 arg2 = (bool)(SWIG_As_bool(obj1));
19727 if (SWIG_arg_fail(2)) SWIG_fail;
19728 }
19729 if (arg1) (arg1)->m_scanCode = arg2;
19730
19731 Py_INCREF(Py_None); resultobj = Py_None;
19732 return resultobj;
19733 fail:
19734 return NULL;
19735 }
19736
19737
19738 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19739 PyObject *resultobj;
19740 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19741 bool result;
19742 PyObject * obj0 = 0 ;
19743 char *kwnames[] = {
19744 (char *) "self", NULL
19745 };
19746
19747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19749 if (SWIG_arg_fail(1)) SWIG_fail;
19750 result = (bool) ((arg1)->m_scanCode);
19751
19752 {
19753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19754 }
19755 return resultobj;
19756 fail:
19757 return NULL;
19758 }
19759
19760
19761 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19764 unsigned int arg2 ;
19765 PyObject * obj0 = 0 ;
19766 PyObject * obj1 = 0 ;
19767 char *kwnames[] = {
19768 (char *) "self",(char *) "m_rawCode", NULL
19769 };
19770
19771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19773 if (SWIG_arg_fail(1)) SWIG_fail;
19774 {
19775 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19776 if (SWIG_arg_fail(2)) SWIG_fail;
19777 }
19778 if (arg1) (arg1)->m_rawCode = arg2;
19779
19780 Py_INCREF(Py_None); resultobj = Py_None;
19781 return resultobj;
19782 fail:
19783 return NULL;
19784 }
19785
19786
19787 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19788 PyObject *resultobj;
19789 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19790 unsigned int result;
19791 PyObject * obj0 = 0 ;
19792 char *kwnames[] = {
19793 (char *) "self", NULL
19794 };
19795
19796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19798 if (SWIG_arg_fail(1)) SWIG_fail;
19799 result = (unsigned int) ((arg1)->m_rawCode);
19800
19801 {
19802 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19803 }
19804 return resultobj;
19805 fail:
19806 return NULL;
19807 }
19808
19809
19810 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19811 PyObject *resultobj;
19812 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19813 unsigned int arg2 ;
19814 PyObject * obj0 = 0 ;
19815 PyObject * obj1 = 0 ;
19816 char *kwnames[] = {
19817 (char *) "self",(char *) "m_rawFlags", NULL
19818 };
19819
19820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19822 if (SWIG_arg_fail(1)) SWIG_fail;
19823 {
19824 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19825 if (SWIG_arg_fail(2)) SWIG_fail;
19826 }
19827 if (arg1) (arg1)->m_rawFlags = arg2;
19828
19829 Py_INCREF(Py_None); resultobj = Py_None;
19830 return resultobj;
19831 fail:
19832 return NULL;
19833 }
19834
19835
19836 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19837 PyObject *resultobj;
19838 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19839 unsigned int result;
19840 PyObject * obj0 = 0 ;
19841 char *kwnames[] = {
19842 (char *) "self", NULL
19843 };
19844
19845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19847 if (SWIG_arg_fail(1)) SWIG_fail;
19848 result = (unsigned int) ((arg1)->m_rawFlags);
19849
19850 {
19851 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19852 }
19853 return resultobj;
19854 fail:
19855 return NULL;
19856 }
19857
19858
19859 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19860 PyObject *obj;
19861 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19862 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19863 Py_INCREF(obj);
19864 return Py_BuildValue((char *)"");
19865 }
19866 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19867 PyObject *resultobj;
19868 wxSize const &arg1_defvalue = wxDefaultSize ;
19869 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19870 int arg2 = (int) 0 ;
19871 wxSizeEvent *result;
19872 wxSize temp1 ;
19873 PyObject * obj0 = 0 ;
19874 PyObject * obj1 = 0 ;
19875 char *kwnames[] = {
19876 (char *) "sz",(char *) "winid", NULL
19877 };
19878
19879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19880 if (obj0) {
19881 {
19882 arg1 = &temp1;
19883 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19884 }
19885 }
19886 if (obj1) {
19887 {
19888 arg2 = (int)(SWIG_As_int(obj1));
19889 if (SWIG_arg_fail(2)) SWIG_fail;
19890 }
19891 }
19892 {
19893 PyThreadState* __tstate = wxPyBeginAllowThreads();
19894 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19895
19896 wxPyEndAllowThreads(__tstate);
19897 if (PyErr_Occurred()) SWIG_fail;
19898 }
19899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19900 return resultobj;
19901 fail:
19902 return NULL;
19903 }
19904
19905
19906 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19907 PyObject *resultobj;
19908 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19909 wxSize result;
19910 PyObject * obj0 = 0 ;
19911 char *kwnames[] = {
19912 (char *) "self", NULL
19913 };
19914
19915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19917 if (SWIG_arg_fail(1)) SWIG_fail;
19918 {
19919 PyThreadState* __tstate = wxPyBeginAllowThreads();
19920 result = ((wxSizeEvent const *)arg1)->GetSize();
19921
19922 wxPyEndAllowThreads(__tstate);
19923 if (PyErr_Occurred()) SWIG_fail;
19924 }
19925 {
19926 wxSize * resultptr;
19927 resultptr = new wxSize((wxSize &)(result));
19928 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19929 }
19930 return resultobj;
19931 fail:
19932 return NULL;
19933 }
19934
19935
19936 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19937 PyObject *resultobj;
19938 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19939 wxRect result;
19940 PyObject * obj0 = 0 ;
19941 char *kwnames[] = {
19942 (char *) "self", NULL
19943 };
19944
19945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19947 if (SWIG_arg_fail(1)) SWIG_fail;
19948 {
19949 PyThreadState* __tstate = wxPyBeginAllowThreads();
19950 result = ((wxSizeEvent const *)arg1)->GetRect();
19951
19952 wxPyEndAllowThreads(__tstate);
19953 if (PyErr_Occurred()) SWIG_fail;
19954 }
19955 {
19956 wxRect * resultptr;
19957 resultptr = new wxRect((wxRect &)(result));
19958 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19959 }
19960 return resultobj;
19961 fail:
19962 return NULL;
19963 }
19964
19965
19966 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19967 PyObject *resultobj;
19968 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19969 wxRect arg2 ;
19970 PyObject * obj0 = 0 ;
19971 PyObject * obj1 = 0 ;
19972 char *kwnames[] = {
19973 (char *) "self",(char *) "rect", NULL
19974 };
19975
19976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19978 if (SWIG_arg_fail(1)) SWIG_fail;
19979 {
19980 wxRect * argp;
19981 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19982 if (SWIG_arg_fail(2)) SWIG_fail;
19983 if (argp == NULL) {
19984 SWIG_null_ref("wxRect");
19985 }
19986 if (SWIG_arg_fail(2)) SWIG_fail;
19987 arg2 = *argp;
19988 }
19989 {
19990 PyThreadState* __tstate = wxPyBeginAllowThreads();
19991 (arg1)->SetRect(arg2);
19992
19993 wxPyEndAllowThreads(__tstate);
19994 if (PyErr_Occurred()) SWIG_fail;
19995 }
19996 Py_INCREF(Py_None); resultobj = Py_None;
19997 return resultobj;
19998 fail:
19999 return NULL;
20000 }
20001
20002
20003 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20004 PyObject *resultobj;
20005 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20006 wxSize arg2 ;
20007 PyObject * obj0 = 0 ;
20008 PyObject * obj1 = 0 ;
20009 char *kwnames[] = {
20010 (char *) "self",(char *) "size", NULL
20011 };
20012
20013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
20014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20015 if (SWIG_arg_fail(1)) SWIG_fail;
20016 {
20017 wxSize * argp;
20018 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
20019 if (SWIG_arg_fail(2)) SWIG_fail;
20020 if (argp == NULL) {
20021 SWIG_null_ref("wxSize");
20022 }
20023 if (SWIG_arg_fail(2)) SWIG_fail;
20024 arg2 = *argp;
20025 }
20026 {
20027 PyThreadState* __tstate = wxPyBeginAllowThreads();
20028 wxSizeEvent_SetSize(arg1,arg2);
20029
20030 wxPyEndAllowThreads(__tstate);
20031 if (PyErr_Occurred()) SWIG_fail;
20032 }
20033 Py_INCREF(Py_None); resultobj = Py_None;
20034 return resultobj;
20035 fail:
20036 return NULL;
20037 }
20038
20039
20040 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20041 PyObject *resultobj;
20042 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20043 wxSize *arg2 = (wxSize *) 0 ;
20044 PyObject * obj0 = 0 ;
20045 PyObject * obj1 = 0 ;
20046 char *kwnames[] = {
20047 (char *) "self",(char *) "m_size", NULL
20048 };
20049
20050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20052 if (SWIG_arg_fail(1)) SWIG_fail;
20053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20054 if (SWIG_arg_fail(2)) SWIG_fail;
20055 if (arg1) (arg1)->m_size = *arg2;
20056
20057 Py_INCREF(Py_None); resultobj = Py_None;
20058 return resultobj;
20059 fail:
20060 return NULL;
20061 }
20062
20063
20064 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20065 PyObject *resultobj;
20066 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20067 wxSize *result;
20068 PyObject * obj0 = 0 ;
20069 char *kwnames[] = {
20070 (char *) "self", NULL
20071 };
20072
20073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
20074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20075 if (SWIG_arg_fail(1)) SWIG_fail;
20076 result = (wxSize *)& ((arg1)->m_size);
20077
20078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20079 return resultobj;
20080 fail:
20081 return NULL;
20082 }
20083
20084
20085 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20086 PyObject *resultobj;
20087 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20088 wxRect *arg2 = (wxRect *) 0 ;
20089 PyObject * obj0 = 0 ;
20090 PyObject * obj1 = 0 ;
20091 char *kwnames[] = {
20092 (char *) "self",(char *) "m_rect", NULL
20093 };
20094
20095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20097 if (SWIG_arg_fail(1)) SWIG_fail;
20098 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20099 if (SWIG_arg_fail(2)) SWIG_fail;
20100 if (arg1) (arg1)->m_rect = *arg2;
20101
20102 Py_INCREF(Py_None); resultobj = Py_None;
20103 return resultobj;
20104 fail:
20105 return NULL;
20106 }
20107
20108
20109 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20110 PyObject *resultobj;
20111 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20112 wxRect *result;
20113 PyObject * obj0 = 0 ;
20114 char *kwnames[] = {
20115 (char *) "self", NULL
20116 };
20117
20118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20120 if (SWIG_arg_fail(1)) SWIG_fail;
20121 result = (wxRect *)& ((arg1)->m_rect);
20122
20123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20124 return resultobj;
20125 fail:
20126 return NULL;
20127 }
20128
20129
20130 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20131 PyObject *obj;
20132 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20133 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20134 Py_INCREF(obj);
20135 return Py_BuildValue((char *)"");
20136 }
20137 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20138 PyObject *resultobj;
20139 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20140 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20141 int arg2 = (int) 0 ;
20142 wxMoveEvent *result;
20143 wxPoint temp1 ;
20144 PyObject * obj0 = 0 ;
20145 PyObject * obj1 = 0 ;
20146 char *kwnames[] = {
20147 (char *) "pos",(char *) "winid", NULL
20148 };
20149
20150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20151 if (obj0) {
20152 {
20153 arg1 = &temp1;
20154 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20155 }
20156 }
20157 if (obj1) {
20158 {
20159 arg2 = (int)(SWIG_As_int(obj1));
20160 if (SWIG_arg_fail(2)) SWIG_fail;
20161 }
20162 }
20163 {
20164 PyThreadState* __tstate = wxPyBeginAllowThreads();
20165 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20166
20167 wxPyEndAllowThreads(__tstate);
20168 if (PyErr_Occurred()) SWIG_fail;
20169 }
20170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20171 return resultobj;
20172 fail:
20173 return NULL;
20174 }
20175
20176
20177 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20178 PyObject *resultobj;
20179 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20180 wxPoint result;
20181 PyObject * obj0 = 0 ;
20182 char *kwnames[] = {
20183 (char *) "self", NULL
20184 };
20185
20186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20188 if (SWIG_arg_fail(1)) SWIG_fail;
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 result = ((wxMoveEvent const *)arg1)->GetPosition();
20192
20193 wxPyEndAllowThreads(__tstate);
20194 if (PyErr_Occurred()) SWIG_fail;
20195 }
20196 {
20197 wxPoint * resultptr;
20198 resultptr = new wxPoint((wxPoint &)(result));
20199 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20200 }
20201 return resultobj;
20202 fail:
20203 return NULL;
20204 }
20205
20206
20207 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20208 PyObject *resultobj;
20209 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20210 wxRect result;
20211 PyObject * obj0 = 0 ;
20212 char *kwnames[] = {
20213 (char *) "self", NULL
20214 };
20215
20216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20218 if (SWIG_arg_fail(1)) SWIG_fail;
20219 {
20220 PyThreadState* __tstate = wxPyBeginAllowThreads();
20221 result = ((wxMoveEvent const *)arg1)->GetRect();
20222
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 {
20227 wxRect * resultptr;
20228 resultptr = new wxRect((wxRect &)(result));
20229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20230 }
20231 return resultobj;
20232 fail:
20233 return NULL;
20234 }
20235
20236
20237 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20238 PyObject *resultobj;
20239 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20240 wxRect *arg2 = 0 ;
20241 wxRect temp2 ;
20242 PyObject * obj0 = 0 ;
20243 PyObject * obj1 = 0 ;
20244 char *kwnames[] = {
20245 (char *) "self",(char *) "rect", NULL
20246 };
20247
20248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20250 if (SWIG_arg_fail(1)) SWIG_fail;
20251 {
20252 arg2 = &temp2;
20253 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20254 }
20255 {
20256 PyThreadState* __tstate = wxPyBeginAllowThreads();
20257 (arg1)->SetRect((wxRect const &)*arg2);
20258
20259 wxPyEndAllowThreads(__tstate);
20260 if (PyErr_Occurred()) SWIG_fail;
20261 }
20262 Py_INCREF(Py_None); resultobj = Py_None;
20263 return resultobj;
20264 fail:
20265 return NULL;
20266 }
20267
20268
20269 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20270 PyObject *resultobj;
20271 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20272 wxPoint *arg2 = 0 ;
20273 wxPoint temp2 ;
20274 PyObject * obj0 = 0 ;
20275 PyObject * obj1 = 0 ;
20276 char *kwnames[] = {
20277 (char *) "self",(char *) "pos", NULL
20278 };
20279
20280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20282 if (SWIG_arg_fail(1)) SWIG_fail;
20283 {
20284 arg2 = &temp2;
20285 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20286 }
20287 {
20288 PyThreadState* __tstate = wxPyBeginAllowThreads();
20289 (arg1)->SetPosition((wxPoint const &)*arg2);
20290
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 Py_INCREF(Py_None); resultobj = Py_None;
20295 return resultobj;
20296 fail:
20297 return NULL;
20298 }
20299
20300
20301 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20302 PyObject *obj;
20303 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20304 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20305 Py_INCREF(obj);
20306 return Py_BuildValue((char *)"");
20307 }
20308 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20309 PyObject *resultobj;
20310 int arg1 = (int) 0 ;
20311 wxPaintEvent *result;
20312 PyObject * obj0 = 0 ;
20313 char *kwnames[] = {
20314 (char *) "Id", NULL
20315 };
20316
20317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20318 if (obj0) {
20319 {
20320 arg1 = (int)(SWIG_As_int(obj0));
20321 if (SWIG_arg_fail(1)) SWIG_fail;
20322 }
20323 }
20324 {
20325 PyThreadState* __tstate = wxPyBeginAllowThreads();
20326 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20327
20328 wxPyEndAllowThreads(__tstate);
20329 if (PyErr_Occurred()) SWIG_fail;
20330 }
20331 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20332 return resultobj;
20333 fail:
20334 return NULL;
20335 }
20336
20337
20338 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20339 PyObject *obj;
20340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20341 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20342 Py_INCREF(obj);
20343 return Py_BuildValue((char *)"");
20344 }
20345 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20346 PyObject *resultobj;
20347 int arg1 = (int) 0 ;
20348 wxNcPaintEvent *result;
20349 PyObject * obj0 = 0 ;
20350 char *kwnames[] = {
20351 (char *) "winid", NULL
20352 };
20353
20354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20355 if (obj0) {
20356 {
20357 arg1 = (int)(SWIG_As_int(obj0));
20358 if (SWIG_arg_fail(1)) SWIG_fail;
20359 }
20360 }
20361 {
20362 PyThreadState* __tstate = wxPyBeginAllowThreads();
20363 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20364
20365 wxPyEndAllowThreads(__tstate);
20366 if (PyErr_Occurred()) SWIG_fail;
20367 }
20368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20369 return resultobj;
20370 fail:
20371 return NULL;
20372 }
20373
20374
20375 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20376 PyObject *obj;
20377 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20378 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20379 Py_INCREF(obj);
20380 return Py_BuildValue((char *)"");
20381 }
20382 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20383 PyObject *resultobj;
20384 int arg1 = (int) 0 ;
20385 wxDC *arg2 = (wxDC *) NULL ;
20386 wxEraseEvent *result;
20387 PyObject * obj0 = 0 ;
20388 PyObject * obj1 = 0 ;
20389 char *kwnames[] = {
20390 (char *) "Id",(char *) "dc", NULL
20391 };
20392
20393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20394 if (obj0) {
20395 {
20396 arg1 = (int)(SWIG_As_int(obj0));
20397 if (SWIG_arg_fail(1)) SWIG_fail;
20398 }
20399 }
20400 if (obj1) {
20401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20402 if (SWIG_arg_fail(2)) SWIG_fail;
20403 }
20404 {
20405 PyThreadState* __tstate = wxPyBeginAllowThreads();
20406 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20407
20408 wxPyEndAllowThreads(__tstate);
20409 if (PyErr_Occurred()) SWIG_fail;
20410 }
20411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20412 return resultobj;
20413 fail:
20414 return NULL;
20415 }
20416
20417
20418 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20419 PyObject *resultobj;
20420 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20421 wxDC *result;
20422 PyObject * obj0 = 0 ;
20423 char *kwnames[] = {
20424 (char *) "self", NULL
20425 };
20426
20427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20429 if (SWIG_arg_fail(1)) SWIG_fail;
20430 {
20431 PyThreadState* __tstate = wxPyBeginAllowThreads();
20432 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20433
20434 wxPyEndAllowThreads(__tstate);
20435 if (PyErr_Occurred()) SWIG_fail;
20436 }
20437 {
20438 resultobj = wxPyMake_wxObject(result, 0);
20439 }
20440 return resultobj;
20441 fail:
20442 return NULL;
20443 }
20444
20445
20446 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20447 PyObject *obj;
20448 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20449 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20450 Py_INCREF(obj);
20451 return Py_BuildValue((char *)"");
20452 }
20453 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20454 PyObject *resultobj;
20455 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20456 int arg2 = (int) 0 ;
20457 wxFocusEvent *result;
20458 PyObject * obj0 = 0 ;
20459 PyObject * obj1 = 0 ;
20460 char *kwnames[] = {
20461 (char *) "type",(char *) "winid", NULL
20462 };
20463
20464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20465 if (obj0) {
20466 {
20467 arg1 = (wxEventType)(SWIG_As_int(obj0));
20468 if (SWIG_arg_fail(1)) SWIG_fail;
20469 }
20470 }
20471 if (obj1) {
20472 {
20473 arg2 = (int)(SWIG_As_int(obj1));
20474 if (SWIG_arg_fail(2)) SWIG_fail;
20475 }
20476 }
20477 {
20478 PyThreadState* __tstate = wxPyBeginAllowThreads();
20479 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20480
20481 wxPyEndAllowThreads(__tstate);
20482 if (PyErr_Occurred()) SWIG_fail;
20483 }
20484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20485 return resultobj;
20486 fail:
20487 return NULL;
20488 }
20489
20490
20491 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20492 PyObject *resultobj;
20493 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20494 wxWindow *result;
20495 PyObject * obj0 = 0 ;
20496 char *kwnames[] = {
20497 (char *) "self", NULL
20498 };
20499
20500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20502 if (SWIG_arg_fail(1)) SWIG_fail;
20503 {
20504 PyThreadState* __tstate = wxPyBeginAllowThreads();
20505 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20506
20507 wxPyEndAllowThreads(__tstate);
20508 if (PyErr_Occurred()) SWIG_fail;
20509 }
20510 {
20511 resultobj = wxPyMake_wxObject(result, 0);
20512 }
20513 return resultobj;
20514 fail:
20515 return NULL;
20516 }
20517
20518
20519 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20520 PyObject *resultobj;
20521 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20522 wxWindow *arg2 = (wxWindow *) 0 ;
20523 PyObject * obj0 = 0 ;
20524 PyObject * obj1 = 0 ;
20525 char *kwnames[] = {
20526 (char *) "self",(char *) "win", NULL
20527 };
20528
20529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20531 if (SWIG_arg_fail(1)) SWIG_fail;
20532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20533 if (SWIG_arg_fail(2)) SWIG_fail;
20534 {
20535 PyThreadState* __tstate = wxPyBeginAllowThreads();
20536 (arg1)->SetWindow(arg2);
20537
20538 wxPyEndAllowThreads(__tstate);
20539 if (PyErr_Occurred()) SWIG_fail;
20540 }
20541 Py_INCREF(Py_None); resultobj = Py_None;
20542 return resultobj;
20543 fail:
20544 return NULL;
20545 }
20546
20547
20548 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20549 PyObject *obj;
20550 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20551 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20552 Py_INCREF(obj);
20553 return Py_BuildValue((char *)"");
20554 }
20555 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20556 PyObject *resultobj;
20557 wxWindow *arg1 = (wxWindow *) NULL ;
20558 wxChildFocusEvent *result;
20559 PyObject * obj0 = 0 ;
20560 char *kwnames[] = {
20561 (char *) "win", NULL
20562 };
20563
20564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20565 if (obj0) {
20566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20567 if (SWIG_arg_fail(1)) SWIG_fail;
20568 }
20569 {
20570 PyThreadState* __tstate = wxPyBeginAllowThreads();
20571 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20572
20573 wxPyEndAllowThreads(__tstate);
20574 if (PyErr_Occurred()) SWIG_fail;
20575 }
20576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20577 return resultobj;
20578 fail:
20579 return NULL;
20580 }
20581
20582
20583 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20584 PyObject *resultobj;
20585 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20586 wxWindow *result;
20587 PyObject * obj0 = 0 ;
20588 char *kwnames[] = {
20589 (char *) "self", NULL
20590 };
20591
20592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20594 if (SWIG_arg_fail(1)) SWIG_fail;
20595 {
20596 PyThreadState* __tstate = wxPyBeginAllowThreads();
20597 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20598
20599 wxPyEndAllowThreads(__tstate);
20600 if (PyErr_Occurred()) SWIG_fail;
20601 }
20602 {
20603 resultobj = wxPyMake_wxObject(result, 0);
20604 }
20605 return resultobj;
20606 fail:
20607 return NULL;
20608 }
20609
20610
20611 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20612 PyObject *obj;
20613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20614 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20615 Py_INCREF(obj);
20616 return Py_BuildValue((char *)"");
20617 }
20618 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20619 PyObject *resultobj;
20620 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20621 bool arg2 = (bool) true ;
20622 int arg3 = (int) 0 ;
20623 wxActivateEvent *result;
20624 PyObject * obj0 = 0 ;
20625 PyObject * obj1 = 0 ;
20626 PyObject * obj2 = 0 ;
20627 char *kwnames[] = {
20628 (char *) "type",(char *) "active",(char *) "Id", NULL
20629 };
20630
20631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20632 if (obj0) {
20633 {
20634 arg1 = (wxEventType)(SWIG_As_int(obj0));
20635 if (SWIG_arg_fail(1)) SWIG_fail;
20636 }
20637 }
20638 if (obj1) {
20639 {
20640 arg2 = (bool)(SWIG_As_bool(obj1));
20641 if (SWIG_arg_fail(2)) SWIG_fail;
20642 }
20643 }
20644 if (obj2) {
20645 {
20646 arg3 = (int)(SWIG_As_int(obj2));
20647 if (SWIG_arg_fail(3)) SWIG_fail;
20648 }
20649 }
20650 {
20651 PyThreadState* __tstate = wxPyBeginAllowThreads();
20652 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20653
20654 wxPyEndAllowThreads(__tstate);
20655 if (PyErr_Occurred()) SWIG_fail;
20656 }
20657 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20658 return resultobj;
20659 fail:
20660 return NULL;
20661 }
20662
20663
20664 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20665 PyObject *resultobj;
20666 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20667 bool result;
20668 PyObject * obj0 = 0 ;
20669 char *kwnames[] = {
20670 (char *) "self", NULL
20671 };
20672
20673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20675 if (SWIG_arg_fail(1)) SWIG_fail;
20676 {
20677 PyThreadState* __tstate = wxPyBeginAllowThreads();
20678 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20679
20680 wxPyEndAllowThreads(__tstate);
20681 if (PyErr_Occurred()) SWIG_fail;
20682 }
20683 {
20684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20685 }
20686 return resultobj;
20687 fail:
20688 return NULL;
20689 }
20690
20691
20692 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20693 PyObject *obj;
20694 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20695 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20696 Py_INCREF(obj);
20697 return Py_BuildValue((char *)"");
20698 }
20699 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20700 PyObject *resultobj;
20701 int arg1 = (int) 0 ;
20702 wxInitDialogEvent *result;
20703 PyObject * obj0 = 0 ;
20704 char *kwnames[] = {
20705 (char *) "Id", NULL
20706 };
20707
20708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20709 if (obj0) {
20710 {
20711 arg1 = (int)(SWIG_As_int(obj0));
20712 if (SWIG_arg_fail(1)) SWIG_fail;
20713 }
20714 }
20715 {
20716 PyThreadState* __tstate = wxPyBeginAllowThreads();
20717 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20718
20719 wxPyEndAllowThreads(__tstate);
20720 if (PyErr_Occurred()) SWIG_fail;
20721 }
20722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20723 return resultobj;
20724 fail:
20725 return NULL;
20726 }
20727
20728
20729 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20730 PyObject *obj;
20731 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20732 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20733 Py_INCREF(obj);
20734 return Py_BuildValue((char *)"");
20735 }
20736 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20737 PyObject *resultobj;
20738 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20739 int arg2 = (int) 0 ;
20740 wxMenu *arg3 = (wxMenu *) NULL ;
20741 wxMenuEvent *result;
20742 PyObject * obj0 = 0 ;
20743 PyObject * obj1 = 0 ;
20744 PyObject * obj2 = 0 ;
20745 char *kwnames[] = {
20746 (char *) "type",(char *) "winid",(char *) "menu", NULL
20747 };
20748
20749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20750 if (obj0) {
20751 {
20752 arg1 = (wxEventType)(SWIG_As_int(obj0));
20753 if (SWIG_arg_fail(1)) SWIG_fail;
20754 }
20755 }
20756 if (obj1) {
20757 {
20758 arg2 = (int)(SWIG_As_int(obj1));
20759 if (SWIG_arg_fail(2)) SWIG_fail;
20760 }
20761 }
20762 if (obj2) {
20763 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20764 if (SWIG_arg_fail(3)) SWIG_fail;
20765 }
20766 {
20767 PyThreadState* __tstate = wxPyBeginAllowThreads();
20768 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20769
20770 wxPyEndAllowThreads(__tstate);
20771 if (PyErr_Occurred()) SWIG_fail;
20772 }
20773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20774 return resultobj;
20775 fail:
20776 return NULL;
20777 }
20778
20779
20780 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20781 PyObject *resultobj;
20782 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20783 int result;
20784 PyObject * obj0 = 0 ;
20785 char *kwnames[] = {
20786 (char *) "self", NULL
20787 };
20788
20789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20791 if (SWIG_arg_fail(1)) SWIG_fail;
20792 {
20793 PyThreadState* __tstate = wxPyBeginAllowThreads();
20794 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20795
20796 wxPyEndAllowThreads(__tstate);
20797 if (PyErr_Occurred()) SWIG_fail;
20798 }
20799 {
20800 resultobj = SWIG_From_int((int)(result));
20801 }
20802 return resultobj;
20803 fail:
20804 return NULL;
20805 }
20806
20807
20808 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20809 PyObject *resultobj;
20810 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20811 bool result;
20812 PyObject * obj0 = 0 ;
20813 char *kwnames[] = {
20814 (char *) "self", NULL
20815 };
20816
20817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20819 if (SWIG_arg_fail(1)) SWIG_fail;
20820 {
20821 PyThreadState* __tstate = wxPyBeginAllowThreads();
20822 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20823
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 {
20828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20829 }
20830 return resultobj;
20831 fail:
20832 return NULL;
20833 }
20834
20835
20836 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20837 PyObject *resultobj;
20838 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20839 wxMenu *result;
20840 PyObject * obj0 = 0 ;
20841 char *kwnames[] = {
20842 (char *) "self", NULL
20843 };
20844
20845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20847 if (SWIG_arg_fail(1)) SWIG_fail;
20848 {
20849 PyThreadState* __tstate = wxPyBeginAllowThreads();
20850 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20851
20852 wxPyEndAllowThreads(__tstate);
20853 if (PyErr_Occurred()) SWIG_fail;
20854 }
20855 {
20856 resultobj = wxPyMake_wxObject(result, 0);
20857 }
20858 return resultobj;
20859 fail:
20860 return NULL;
20861 }
20862
20863
20864 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20865 PyObject *obj;
20866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20867 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20868 Py_INCREF(obj);
20869 return Py_BuildValue((char *)"");
20870 }
20871 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20872 PyObject *resultobj;
20873 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20874 int arg2 = (int) 0 ;
20875 wxCloseEvent *result;
20876 PyObject * obj0 = 0 ;
20877 PyObject * obj1 = 0 ;
20878 char *kwnames[] = {
20879 (char *) "type",(char *) "winid", NULL
20880 };
20881
20882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20883 if (obj0) {
20884 {
20885 arg1 = (wxEventType)(SWIG_As_int(obj0));
20886 if (SWIG_arg_fail(1)) SWIG_fail;
20887 }
20888 }
20889 if (obj1) {
20890 {
20891 arg2 = (int)(SWIG_As_int(obj1));
20892 if (SWIG_arg_fail(2)) SWIG_fail;
20893 }
20894 }
20895 {
20896 PyThreadState* __tstate = wxPyBeginAllowThreads();
20897 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20898
20899 wxPyEndAllowThreads(__tstate);
20900 if (PyErr_Occurred()) SWIG_fail;
20901 }
20902 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20903 return resultobj;
20904 fail:
20905 return NULL;
20906 }
20907
20908
20909 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20910 PyObject *resultobj;
20911 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20912 bool arg2 ;
20913 PyObject * obj0 = 0 ;
20914 PyObject * obj1 = 0 ;
20915 char *kwnames[] = {
20916 (char *) "self",(char *) "logOff", NULL
20917 };
20918
20919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20921 if (SWIG_arg_fail(1)) SWIG_fail;
20922 {
20923 arg2 = (bool)(SWIG_As_bool(obj1));
20924 if (SWIG_arg_fail(2)) SWIG_fail;
20925 }
20926 {
20927 PyThreadState* __tstate = wxPyBeginAllowThreads();
20928 (arg1)->SetLoggingOff(arg2);
20929
20930 wxPyEndAllowThreads(__tstate);
20931 if (PyErr_Occurred()) SWIG_fail;
20932 }
20933 Py_INCREF(Py_None); resultobj = Py_None;
20934 return resultobj;
20935 fail:
20936 return NULL;
20937 }
20938
20939
20940 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20941 PyObject *resultobj;
20942 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20943 bool result;
20944 PyObject * obj0 = 0 ;
20945 char *kwnames[] = {
20946 (char *) "self", NULL
20947 };
20948
20949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20951 if (SWIG_arg_fail(1)) SWIG_fail;
20952 {
20953 PyThreadState* __tstate = wxPyBeginAllowThreads();
20954 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20955
20956 wxPyEndAllowThreads(__tstate);
20957 if (PyErr_Occurred()) SWIG_fail;
20958 }
20959 {
20960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20961 }
20962 return resultobj;
20963 fail:
20964 return NULL;
20965 }
20966
20967
20968 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20969 PyObject *resultobj;
20970 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20971 bool arg2 = (bool) true ;
20972 PyObject * obj0 = 0 ;
20973 PyObject * obj1 = 0 ;
20974 char *kwnames[] = {
20975 (char *) "self",(char *) "veto", NULL
20976 };
20977
20978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20980 if (SWIG_arg_fail(1)) SWIG_fail;
20981 if (obj1) {
20982 {
20983 arg2 = (bool)(SWIG_As_bool(obj1));
20984 if (SWIG_arg_fail(2)) SWIG_fail;
20985 }
20986 }
20987 {
20988 PyThreadState* __tstate = wxPyBeginAllowThreads();
20989 (arg1)->Veto(arg2);
20990
20991 wxPyEndAllowThreads(__tstate);
20992 if (PyErr_Occurred()) SWIG_fail;
20993 }
20994 Py_INCREF(Py_None); resultobj = Py_None;
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21002 PyObject *resultobj;
21003 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21004 bool result;
21005 PyObject * obj0 = 0 ;
21006 char *kwnames[] = {
21007 (char *) "self", NULL
21008 };
21009
21010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
21011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21012 if (SWIG_arg_fail(1)) SWIG_fail;
21013 {
21014 PyThreadState* __tstate = wxPyBeginAllowThreads();
21015 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
21016
21017 wxPyEndAllowThreads(__tstate);
21018 if (PyErr_Occurred()) SWIG_fail;
21019 }
21020 {
21021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21022 }
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21030 PyObject *resultobj;
21031 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21032 bool arg2 ;
21033 PyObject * obj0 = 0 ;
21034 PyObject * obj1 = 0 ;
21035 char *kwnames[] = {
21036 (char *) "self",(char *) "canVeto", NULL
21037 };
21038
21039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21041 if (SWIG_arg_fail(1)) SWIG_fail;
21042 {
21043 arg2 = (bool)(SWIG_As_bool(obj1));
21044 if (SWIG_arg_fail(2)) SWIG_fail;
21045 }
21046 {
21047 PyThreadState* __tstate = wxPyBeginAllowThreads();
21048 (arg1)->SetCanVeto(arg2);
21049
21050 wxPyEndAllowThreads(__tstate);
21051 if (PyErr_Occurred()) SWIG_fail;
21052 }
21053 Py_INCREF(Py_None); resultobj = Py_None;
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21061 PyObject *resultobj;
21062 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21063 bool result;
21064 PyObject * obj0 = 0 ;
21065 char *kwnames[] = {
21066 (char *) "self", NULL
21067 };
21068
21069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21071 if (SWIG_arg_fail(1)) SWIG_fail;
21072 {
21073 PyThreadState* __tstate = wxPyBeginAllowThreads();
21074 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21075
21076 wxPyEndAllowThreads(__tstate);
21077 if (PyErr_Occurred()) SWIG_fail;
21078 }
21079 {
21080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21081 }
21082 return resultobj;
21083 fail:
21084 return NULL;
21085 }
21086
21087
21088 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21089 PyObject *obj;
21090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21091 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21092 Py_INCREF(obj);
21093 return Py_BuildValue((char *)"");
21094 }
21095 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21096 PyObject *resultobj;
21097 int arg1 = (int) 0 ;
21098 bool arg2 = (bool) false ;
21099 wxShowEvent *result;
21100 PyObject * obj0 = 0 ;
21101 PyObject * obj1 = 0 ;
21102 char *kwnames[] = {
21103 (char *) "winid",(char *) "show", NULL
21104 };
21105
21106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21107 if (obj0) {
21108 {
21109 arg1 = (int)(SWIG_As_int(obj0));
21110 if (SWIG_arg_fail(1)) SWIG_fail;
21111 }
21112 }
21113 if (obj1) {
21114 {
21115 arg2 = (bool)(SWIG_As_bool(obj1));
21116 if (SWIG_arg_fail(2)) SWIG_fail;
21117 }
21118 }
21119 {
21120 PyThreadState* __tstate = wxPyBeginAllowThreads();
21121 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21122
21123 wxPyEndAllowThreads(__tstate);
21124 if (PyErr_Occurred()) SWIG_fail;
21125 }
21126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21127 return resultobj;
21128 fail:
21129 return NULL;
21130 }
21131
21132
21133 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21134 PyObject *resultobj;
21135 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21136 bool arg2 ;
21137 PyObject * obj0 = 0 ;
21138 PyObject * obj1 = 0 ;
21139 char *kwnames[] = {
21140 (char *) "self",(char *) "show", NULL
21141 };
21142
21143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21145 if (SWIG_arg_fail(1)) SWIG_fail;
21146 {
21147 arg2 = (bool)(SWIG_As_bool(obj1));
21148 if (SWIG_arg_fail(2)) SWIG_fail;
21149 }
21150 {
21151 PyThreadState* __tstate = wxPyBeginAllowThreads();
21152 (arg1)->SetShow(arg2);
21153
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 Py_INCREF(Py_None); resultobj = Py_None;
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21165 PyObject *resultobj;
21166 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21167 bool result;
21168 PyObject * obj0 = 0 ;
21169 char *kwnames[] = {
21170 (char *) "self", NULL
21171 };
21172
21173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21175 if (SWIG_arg_fail(1)) SWIG_fail;
21176 {
21177 PyThreadState* __tstate = wxPyBeginAllowThreads();
21178 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21179
21180 wxPyEndAllowThreads(__tstate);
21181 if (PyErr_Occurred()) SWIG_fail;
21182 }
21183 {
21184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21185 }
21186 return resultobj;
21187 fail:
21188 return NULL;
21189 }
21190
21191
21192 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21193 PyObject *obj;
21194 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21195 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21196 Py_INCREF(obj);
21197 return Py_BuildValue((char *)"");
21198 }
21199 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21200 PyObject *resultobj;
21201 int arg1 = (int) 0 ;
21202 bool arg2 = (bool) true ;
21203 wxIconizeEvent *result;
21204 PyObject * obj0 = 0 ;
21205 PyObject * obj1 = 0 ;
21206 char *kwnames[] = {
21207 (char *) "id",(char *) "iconized", NULL
21208 };
21209
21210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21211 if (obj0) {
21212 {
21213 arg1 = (int)(SWIG_As_int(obj0));
21214 if (SWIG_arg_fail(1)) SWIG_fail;
21215 }
21216 }
21217 if (obj1) {
21218 {
21219 arg2 = (bool)(SWIG_As_bool(obj1));
21220 if (SWIG_arg_fail(2)) SWIG_fail;
21221 }
21222 }
21223 {
21224 PyThreadState* __tstate = wxPyBeginAllowThreads();
21225 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21226
21227 wxPyEndAllowThreads(__tstate);
21228 if (PyErr_Occurred()) SWIG_fail;
21229 }
21230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21231 return resultobj;
21232 fail:
21233 return NULL;
21234 }
21235
21236
21237 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21238 PyObject *resultobj;
21239 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21240 bool result;
21241 PyObject * obj0 = 0 ;
21242 char *kwnames[] = {
21243 (char *) "self", NULL
21244 };
21245
21246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21248 if (SWIG_arg_fail(1)) SWIG_fail;
21249 {
21250 PyThreadState* __tstate = wxPyBeginAllowThreads();
21251 result = (bool)(arg1)->Iconized();
21252
21253 wxPyEndAllowThreads(__tstate);
21254 if (PyErr_Occurred()) SWIG_fail;
21255 }
21256 {
21257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21258 }
21259 return resultobj;
21260 fail:
21261 return NULL;
21262 }
21263
21264
21265 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21266 PyObject *obj;
21267 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21268 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21269 Py_INCREF(obj);
21270 return Py_BuildValue((char *)"");
21271 }
21272 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21273 PyObject *resultobj;
21274 int arg1 = (int) 0 ;
21275 wxMaximizeEvent *result;
21276 PyObject * obj0 = 0 ;
21277 char *kwnames[] = {
21278 (char *) "id", NULL
21279 };
21280
21281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21282 if (obj0) {
21283 {
21284 arg1 = (int)(SWIG_As_int(obj0));
21285 if (SWIG_arg_fail(1)) SWIG_fail;
21286 }
21287 }
21288 {
21289 PyThreadState* __tstate = wxPyBeginAllowThreads();
21290 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21291
21292 wxPyEndAllowThreads(__tstate);
21293 if (PyErr_Occurred()) SWIG_fail;
21294 }
21295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21296 return resultobj;
21297 fail:
21298 return NULL;
21299 }
21300
21301
21302 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21303 PyObject *obj;
21304 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21305 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21306 Py_INCREF(obj);
21307 return Py_BuildValue((char *)"");
21308 }
21309 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21310 PyObject *resultobj;
21311 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21312 wxPoint result;
21313 PyObject * obj0 = 0 ;
21314 char *kwnames[] = {
21315 (char *) "self", NULL
21316 };
21317
21318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21320 if (SWIG_arg_fail(1)) SWIG_fail;
21321 {
21322 PyThreadState* __tstate = wxPyBeginAllowThreads();
21323 result = (arg1)->GetPosition();
21324
21325 wxPyEndAllowThreads(__tstate);
21326 if (PyErr_Occurred()) SWIG_fail;
21327 }
21328 {
21329 wxPoint * resultptr;
21330 resultptr = new wxPoint((wxPoint &)(result));
21331 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21332 }
21333 return resultobj;
21334 fail:
21335 return NULL;
21336 }
21337
21338
21339 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21340 PyObject *resultobj;
21341 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21342 int result;
21343 PyObject * obj0 = 0 ;
21344 char *kwnames[] = {
21345 (char *) "self", NULL
21346 };
21347
21348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21350 if (SWIG_arg_fail(1)) SWIG_fail;
21351 {
21352 PyThreadState* __tstate = wxPyBeginAllowThreads();
21353 result = (int)(arg1)->GetNumberOfFiles();
21354
21355 wxPyEndAllowThreads(__tstate);
21356 if (PyErr_Occurred()) SWIG_fail;
21357 }
21358 {
21359 resultobj = SWIG_From_int((int)(result));
21360 }
21361 return resultobj;
21362 fail:
21363 return NULL;
21364 }
21365
21366
21367 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21368 PyObject *resultobj;
21369 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21370 PyObject *result;
21371 PyObject * obj0 = 0 ;
21372 char *kwnames[] = {
21373 (char *) "self", NULL
21374 };
21375
21376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21378 if (SWIG_arg_fail(1)) SWIG_fail;
21379 {
21380 PyThreadState* __tstate = wxPyBeginAllowThreads();
21381 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21382
21383 wxPyEndAllowThreads(__tstate);
21384 if (PyErr_Occurred()) SWIG_fail;
21385 }
21386 resultobj = result;
21387 return resultobj;
21388 fail:
21389 return NULL;
21390 }
21391
21392
21393 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21394 PyObject *obj;
21395 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21396 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21397 Py_INCREF(obj);
21398 return Py_BuildValue((char *)"");
21399 }
21400 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21401 PyObject *resultobj;
21402 int arg1 = (int) 0 ;
21403 wxUpdateUIEvent *result;
21404 PyObject * obj0 = 0 ;
21405 char *kwnames[] = {
21406 (char *) "commandId", NULL
21407 };
21408
21409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21410 if (obj0) {
21411 {
21412 arg1 = (int)(SWIG_As_int(obj0));
21413 if (SWIG_arg_fail(1)) SWIG_fail;
21414 }
21415 }
21416 {
21417 PyThreadState* __tstate = wxPyBeginAllowThreads();
21418 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21419
21420 wxPyEndAllowThreads(__tstate);
21421 if (PyErr_Occurred()) SWIG_fail;
21422 }
21423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21424 return resultobj;
21425 fail:
21426 return NULL;
21427 }
21428
21429
21430 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21431 PyObject *resultobj;
21432 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21433 bool result;
21434 PyObject * obj0 = 0 ;
21435 char *kwnames[] = {
21436 (char *) "self", NULL
21437 };
21438
21439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21441 if (SWIG_arg_fail(1)) SWIG_fail;
21442 {
21443 PyThreadState* __tstate = wxPyBeginAllowThreads();
21444 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21445
21446 wxPyEndAllowThreads(__tstate);
21447 if (PyErr_Occurred()) SWIG_fail;
21448 }
21449 {
21450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21451 }
21452 return resultobj;
21453 fail:
21454 return NULL;
21455 }
21456
21457
21458 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21459 PyObject *resultobj;
21460 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21461 bool result;
21462 PyObject * obj0 = 0 ;
21463 char *kwnames[] = {
21464 (char *) "self", NULL
21465 };
21466
21467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21469 if (SWIG_arg_fail(1)) SWIG_fail;
21470 {
21471 PyThreadState* __tstate = wxPyBeginAllowThreads();
21472 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21473
21474 wxPyEndAllowThreads(__tstate);
21475 if (PyErr_Occurred()) SWIG_fail;
21476 }
21477 {
21478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21479 }
21480 return resultobj;
21481 fail:
21482 return NULL;
21483 }
21484
21485
21486 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21487 PyObject *resultobj;
21488 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21489 wxString result;
21490 PyObject * obj0 = 0 ;
21491 char *kwnames[] = {
21492 (char *) "self", NULL
21493 };
21494
21495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21497 if (SWIG_arg_fail(1)) SWIG_fail;
21498 {
21499 PyThreadState* __tstate = wxPyBeginAllowThreads();
21500 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21501
21502 wxPyEndAllowThreads(__tstate);
21503 if (PyErr_Occurred()) SWIG_fail;
21504 }
21505 {
21506 #if wxUSE_UNICODE
21507 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21508 #else
21509 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21510 #endif
21511 }
21512 return resultobj;
21513 fail:
21514 return NULL;
21515 }
21516
21517
21518 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21519 PyObject *resultobj;
21520 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21521 bool result;
21522 PyObject * obj0 = 0 ;
21523 char *kwnames[] = {
21524 (char *) "self", NULL
21525 };
21526
21527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21529 if (SWIG_arg_fail(1)) SWIG_fail;
21530 {
21531 PyThreadState* __tstate = wxPyBeginAllowThreads();
21532 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21533
21534 wxPyEndAllowThreads(__tstate);
21535 if (PyErr_Occurred()) SWIG_fail;
21536 }
21537 {
21538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21539 }
21540 return resultobj;
21541 fail:
21542 return NULL;
21543 }
21544
21545
21546 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21547 PyObject *resultobj;
21548 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21549 bool result;
21550 PyObject * obj0 = 0 ;
21551 char *kwnames[] = {
21552 (char *) "self", NULL
21553 };
21554
21555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21557 if (SWIG_arg_fail(1)) SWIG_fail;
21558 {
21559 PyThreadState* __tstate = wxPyBeginAllowThreads();
21560 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21561
21562 wxPyEndAllowThreads(__tstate);
21563 if (PyErr_Occurred()) SWIG_fail;
21564 }
21565 {
21566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21567 }
21568 return resultobj;
21569 fail:
21570 return NULL;
21571 }
21572
21573
21574 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21575 PyObject *resultobj;
21576 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21577 bool result;
21578 PyObject * obj0 = 0 ;
21579 char *kwnames[] = {
21580 (char *) "self", NULL
21581 };
21582
21583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21585 if (SWIG_arg_fail(1)) SWIG_fail;
21586 {
21587 PyThreadState* __tstate = wxPyBeginAllowThreads();
21588 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21589
21590 wxPyEndAllowThreads(__tstate);
21591 if (PyErr_Occurred()) SWIG_fail;
21592 }
21593 {
21594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21595 }
21596 return resultobj;
21597 fail:
21598 return NULL;
21599 }
21600
21601
21602 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21603 PyObject *resultobj;
21604 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21605 bool arg2 ;
21606 PyObject * obj0 = 0 ;
21607 PyObject * obj1 = 0 ;
21608 char *kwnames[] = {
21609 (char *) "self",(char *) "check", NULL
21610 };
21611
21612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21614 if (SWIG_arg_fail(1)) SWIG_fail;
21615 {
21616 arg2 = (bool)(SWIG_As_bool(obj1));
21617 if (SWIG_arg_fail(2)) SWIG_fail;
21618 }
21619 {
21620 PyThreadState* __tstate = wxPyBeginAllowThreads();
21621 (arg1)->Check(arg2);
21622
21623 wxPyEndAllowThreads(__tstate);
21624 if (PyErr_Occurred()) SWIG_fail;
21625 }
21626 Py_INCREF(Py_None); resultobj = Py_None;
21627 return resultobj;
21628 fail:
21629 return NULL;
21630 }
21631
21632
21633 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21634 PyObject *resultobj;
21635 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21636 bool arg2 ;
21637 PyObject * obj0 = 0 ;
21638 PyObject * obj1 = 0 ;
21639 char *kwnames[] = {
21640 (char *) "self",(char *) "enable", NULL
21641 };
21642
21643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21645 if (SWIG_arg_fail(1)) SWIG_fail;
21646 {
21647 arg2 = (bool)(SWIG_As_bool(obj1));
21648 if (SWIG_arg_fail(2)) SWIG_fail;
21649 }
21650 {
21651 PyThreadState* __tstate = wxPyBeginAllowThreads();
21652 (arg1)->Enable(arg2);
21653
21654 wxPyEndAllowThreads(__tstate);
21655 if (PyErr_Occurred()) SWIG_fail;
21656 }
21657 Py_INCREF(Py_None); resultobj = Py_None;
21658 return resultobj;
21659 fail:
21660 return NULL;
21661 }
21662
21663
21664 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21665 PyObject *resultobj;
21666 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21667 wxString *arg2 = 0 ;
21668 bool temp2 = false ;
21669 PyObject * obj0 = 0 ;
21670 PyObject * obj1 = 0 ;
21671 char *kwnames[] = {
21672 (char *) "self",(char *) "text", NULL
21673 };
21674
21675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21677 if (SWIG_arg_fail(1)) SWIG_fail;
21678 {
21679 arg2 = wxString_in_helper(obj1);
21680 if (arg2 == NULL) SWIG_fail;
21681 temp2 = true;
21682 }
21683 {
21684 PyThreadState* __tstate = wxPyBeginAllowThreads();
21685 (arg1)->SetText((wxString const &)*arg2);
21686
21687 wxPyEndAllowThreads(__tstate);
21688 if (PyErr_Occurred()) SWIG_fail;
21689 }
21690 Py_INCREF(Py_None); resultobj = Py_None;
21691 {
21692 if (temp2)
21693 delete arg2;
21694 }
21695 return resultobj;
21696 fail:
21697 {
21698 if (temp2)
21699 delete arg2;
21700 }
21701 return NULL;
21702 }
21703
21704
21705 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21706 PyObject *resultobj;
21707 long arg1 ;
21708 PyObject * obj0 = 0 ;
21709 char *kwnames[] = {
21710 (char *) "updateInterval", NULL
21711 };
21712
21713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21714 {
21715 arg1 = (long)(SWIG_As_long(obj0));
21716 if (SWIG_arg_fail(1)) SWIG_fail;
21717 }
21718 {
21719 PyThreadState* __tstate = wxPyBeginAllowThreads();
21720 wxUpdateUIEvent::SetUpdateInterval(arg1);
21721
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 Py_INCREF(Py_None); resultobj = Py_None;
21726 return resultobj;
21727 fail:
21728 return NULL;
21729 }
21730
21731
21732 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21733 PyObject *resultobj;
21734 long result;
21735 char *kwnames[] = {
21736 NULL
21737 };
21738
21739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21740 {
21741 PyThreadState* __tstate = wxPyBeginAllowThreads();
21742 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21743
21744 wxPyEndAllowThreads(__tstate);
21745 if (PyErr_Occurred()) SWIG_fail;
21746 }
21747 {
21748 resultobj = SWIG_From_long((long)(result));
21749 }
21750 return resultobj;
21751 fail:
21752 return NULL;
21753 }
21754
21755
21756 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21757 PyObject *resultobj;
21758 wxWindow *arg1 = (wxWindow *) 0 ;
21759 bool result;
21760 PyObject * obj0 = 0 ;
21761 char *kwnames[] = {
21762 (char *) "win", NULL
21763 };
21764
21765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21767 if (SWIG_arg_fail(1)) SWIG_fail;
21768 {
21769 PyThreadState* __tstate = wxPyBeginAllowThreads();
21770 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21771
21772 wxPyEndAllowThreads(__tstate);
21773 if (PyErr_Occurred()) SWIG_fail;
21774 }
21775 {
21776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21777 }
21778 return resultobj;
21779 fail:
21780 return NULL;
21781 }
21782
21783
21784 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21785 PyObject *resultobj;
21786 char *kwnames[] = {
21787 NULL
21788 };
21789
21790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21791 {
21792 PyThreadState* __tstate = wxPyBeginAllowThreads();
21793 wxUpdateUIEvent::ResetUpdateTime();
21794
21795 wxPyEndAllowThreads(__tstate);
21796 if (PyErr_Occurred()) SWIG_fail;
21797 }
21798 Py_INCREF(Py_None); resultobj = Py_None;
21799 return resultobj;
21800 fail:
21801 return NULL;
21802 }
21803
21804
21805 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21806 PyObject *resultobj;
21807 wxUpdateUIMode arg1 ;
21808 PyObject * obj0 = 0 ;
21809 char *kwnames[] = {
21810 (char *) "mode", NULL
21811 };
21812
21813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21814 {
21815 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21816 if (SWIG_arg_fail(1)) SWIG_fail;
21817 }
21818 {
21819 PyThreadState* __tstate = wxPyBeginAllowThreads();
21820 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21821
21822 wxPyEndAllowThreads(__tstate);
21823 if (PyErr_Occurred()) SWIG_fail;
21824 }
21825 Py_INCREF(Py_None); resultobj = Py_None;
21826 return resultobj;
21827 fail:
21828 return NULL;
21829 }
21830
21831
21832 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21833 PyObject *resultobj;
21834 wxUpdateUIMode result;
21835 char *kwnames[] = {
21836 NULL
21837 };
21838
21839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21840 {
21841 PyThreadState* __tstate = wxPyBeginAllowThreads();
21842 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21843
21844 wxPyEndAllowThreads(__tstate);
21845 if (PyErr_Occurred()) SWIG_fail;
21846 }
21847 resultobj = SWIG_From_int((result));
21848 return resultobj;
21849 fail:
21850 return NULL;
21851 }
21852
21853
21854 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21855 PyObject *obj;
21856 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21857 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21858 Py_INCREF(obj);
21859 return Py_BuildValue((char *)"");
21860 }
21861 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21862 PyObject *resultobj;
21863 wxSysColourChangedEvent *result;
21864 char *kwnames[] = {
21865 NULL
21866 };
21867
21868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21869 {
21870 PyThreadState* __tstate = wxPyBeginAllowThreads();
21871 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21872
21873 wxPyEndAllowThreads(__tstate);
21874 if (PyErr_Occurred()) SWIG_fail;
21875 }
21876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21877 return resultobj;
21878 fail:
21879 return NULL;
21880 }
21881
21882
21883 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21884 PyObject *obj;
21885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21886 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21887 Py_INCREF(obj);
21888 return Py_BuildValue((char *)"");
21889 }
21890 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21891 PyObject *resultobj;
21892 int arg1 = (int) 0 ;
21893 wxWindow *arg2 = (wxWindow *) NULL ;
21894 wxMouseCaptureChangedEvent *result;
21895 PyObject * obj0 = 0 ;
21896 PyObject * obj1 = 0 ;
21897 char *kwnames[] = {
21898 (char *) "winid",(char *) "gainedCapture", NULL
21899 };
21900
21901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21902 if (obj0) {
21903 {
21904 arg1 = (int)(SWIG_As_int(obj0));
21905 if (SWIG_arg_fail(1)) SWIG_fail;
21906 }
21907 }
21908 if (obj1) {
21909 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21910 if (SWIG_arg_fail(2)) SWIG_fail;
21911 }
21912 {
21913 PyThreadState* __tstate = wxPyBeginAllowThreads();
21914 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21915
21916 wxPyEndAllowThreads(__tstate);
21917 if (PyErr_Occurred()) SWIG_fail;
21918 }
21919 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21920 return resultobj;
21921 fail:
21922 return NULL;
21923 }
21924
21925
21926 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21927 PyObject *resultobj;
21928 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21929 wxWindow *result;
21930 PyObject * obj0 = 0 ;
21931 char *kwnames[] = {
21932 (char *) "self", NULL
21933 };
21934
21935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21937 if (SWIG_arg_fail(1)) SWIG_fail;
21938 {
21939 PyThreadState* __tstate = wxPyBeginAllowThreads();
21940 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21941
21942 wxPyEndAllowThreads(__tstate);
21943 if (PyErr_Occurred()) SWIG_fail;
21944 }
21945 {
21946 resultobj = wxPyMake_wxObject(result, 0);
21947 }
21948 return resultobj;
21949 fail:
21950 return NULL;
21951 }
21952
21953
21954 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21955 PyObject *obj;
21956 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21957 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21958 Py_INCREF(obj);
21959 return Py_BuildValue((char *)"");
21960 }
21961 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21962 PyObject *resultobj;
21963 wxDisplayChangedEvent *result;
21964 char *kwnames[] = {
21965 NULL
21966 };
21967
21968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21969 {
21970 PyThreadState* __tstate = wxPyBeginAllowThreads();
21971 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21972
21973 wxPyEndAllowThreads(__tstate);
21974 if (PyErr_Occurred()) SWIG_fail;
21975 }
21976 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21977 return resultobj;
21978 fail:
21979 return NULL;
21980 }
21981
21982
21983 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21984 PyObject *obj;
21985 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21986 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21987 Py_INCREF(obj);
21988 return Py_BuildValue((char *)"");
21989 }
21990 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21991 PyObject *resultobj;
21992 int arg1 = (int) 0 ;
21993 wxPaletteChangedEvent *result;
21994 PyObject * obj0 = 0 ;
21995 char *kwnames[] = {
21996 (char *) "id", NULL
21997 };
21998
21999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
22000 if (obj0) {
22001 {
22002 arg1 = (int)(SWIG_As_int(obj0));
22003 if (SWIG_arg_fail(1)) SWIG_fail;
22004 }
22005 }
22006 {
22007 PyThreadState* __tstate = wxPyBeginAllowThreads();
22008 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
22009
22010 wxPyEndAllowThreads(__tstate);
22011 if (PyErr_Occurred()) SWIG_fail;
22012 }
22013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
22014 return resultobj;
22015 fail:
22016 return NULL;
22017 }
22018
22019
22020 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22021 PyObject *resultobj;
22022 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22023 wxWindow *arg2 = (wxWindow *) 0 ;
22024 PyObject * obj0 = 0 ;
22025 PyObject * obj1 = 0 ;
22026 char *kwnames[] = {
22027 (char *) "self",(char *) "win", NULL
22028 };
22029
22030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22032 if (SWIG_arg_fail(1)) SWIG_fail;
22033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22034 if (SWIG_arg_fail(2)) SWIG_fail;
22035 {
22036 PyThreadState* __tstate = wxPyBeginAllowThreads();
22037 (arg1)->SetChangedWindow(arg2);
22038
22039 wxPyEndAllowThreads(__tstate);
22040 if (PyErr_Occurred()) SWIG_fail;
22041 }
22042 Py_INCREF(Py_None); resultobj = Py_None;
22043 return resultobj;
22044 fail:
22045 return NULL;
22046 }
22047
22048
22049 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22050 PyObject *resultobj;
22051 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22052 wxWindow *result;
22053 PyObject * obj0 = 0 ;
22054 char *kwnames[] = {
22055 (char *) "self", NULL
22056 };
22057
22058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22060 if (SWIG_arg_fail(1)) SWIG_fail;
22061 {
22062 PyThreadState* __tstate = wxPyBeginAllowThreads();
22063 result = (wxWindow *)(arg1)->GetChangedWindow();
22064
22065 wxPyEndAllowThreads(__tstate);
22066 if (PyErr_Occurred()) SWIG_fail;
22067 }
22068 {
22069 resultobj = wxPyMake_wxObject(result, 0);
22070 }
22071 return resultobj;
22072 fail:
22073 return NULL;
22074 }
22075
22076
22077 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22078 PyObject *obj;
22079 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22080 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22081 Py_INCREF(obj);
22082 return Py_BuildValue((char *)"");
22083 }
22084 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22085 PyObject *resultobj;
22086 int arg1 = (int) 0 ;
22087 wxQueryNewPaletteEvent *result;
22088 PyObject * obj0 = 0 ;
22089 char *kwnames[] = {
22090 (char *) "winid", NULL
22091 };
22092
22093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22094 if (obj0) {
22095 {
22096 arg1 = (int)(SWIG_As_int(obj0));
22097 if (SWIG_arg_fail(1)) SWIG_fail;
22098 }
22099 }
22100 {
22101 PyThreadState* __tstate = wxPyBeginAllowThreads();
22102 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22103
22104 wxPyEndAllowThreads(__tstate);
22105 if (PyErr_Occurred()) SWIG_fail;
22106 }
22107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22108 return resultobj;
22109 fail:
22110 return NULL;
22111 }
22112
22113
22114 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22115 PyObject *resultobj;
22116 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22117 bool arg2 ;
22118 PyObject * obj0 = 0 ;
22119 PyObject * obj1 = 0 ;
22120 char *kwnames[] = {
22121 (char *) "self",(char *) "realized", NULL
22122 };
22123
22124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22126 if (SWIG_arg_fail(1)) SWIG_fail;
22127 {
22128 arg2 = (bool)(SWIG_As_bool(obj1));
22129 if (SWIG_arg_fail(2)) SWIG_fail;
22130 }
22131 {
22132 PyThreadState* __tstate = wxPyBeginAllowThreads();
22133 (arg1)->SetPaletteRealized(arg2);
22134
22135 wxPyEndAllowThreads(__tstate);
22136 if (PyErr_Occurred()) SWIG_fail;
22137 }
22138 Py_INCREF(Py_None); resultobj = Py_None;
22139 return resultobj;
22140 fail:
22141 return NULL;
22142 }
22143
22144
22145 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22146 PyObject *resultobj;
22147 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22148 bool result;
22149 PyObject * obj0 = 0 ;
22150 char *kwnames[] = {
22151 (char *) "self", NULL
22152 };
22153
22154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22156 if (SWIG_arg_fail(1)) SWIG_fail;
22157 {
22158 PyThreadState* __tstate = wxPyBeginAllowThreads();
22159 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22160
22161 wxPyEndAllowThreads(__tstate);
22162 if (PyErr_Occurred()) SWIG_fail;
22163 }
22164 {
22165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22166 }
22167 return resultobj;
22168 fail:
22169 return NULL;
22170 }
22171
22172
22173 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22174 PyObject *obj;
22175 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22176 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22177 Py_INCREF(obj);
22178 return Py_BuildValue((char *)"");
22179 }
22180 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22181 PyObject *resultobj;
22182 wxNavigationKeyEvent *result;
22183 char *kwnames[] = {
22184 NULL
22185 };
22186
22187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22188 {
22189 PyThreadState* __tstate = wxPyBeginAllowThreads();
22190 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22191
22192 wxPyEndAllowThreads(__tstate);
22193 if (PyErr_Occurred()) SWIG_fail;
22194 }
22195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22196 return resultobj;
22197 fail:
22198 return NULL;
22199 }
22200
22201
22202 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22203 PyObject *resultobj;
22204 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22205 bool result;
22206 PyObject * obj0 = 0 ;
22207 char *kwnames[] = {
22208 (char *) "self", NULL
22209 };
22210
22211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22213 if (SWIG_arg_fail(1)) SWIG_fail;
22214 {
22215 PyThreadState* __tstate = wxPyBeginAllowThreads();
22216 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22217
22218 wxPyEndAllowThreads(__tstate);
22219 if (PyErr_Occurred()) SWIG_fail;
22220 }
22221 {
22222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22223 }
22224 return resultobj;
22225 fail:
22226 return NULL;
22227 }
22228
22229
22230 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22231 PyObject *resultobj;
22232 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22233 bool arg2 ;
22234 PyObject * obj0 = 0 ;
22235 PyObject * obj1 = 0 ;
22236 char *kwnames[] = {
22237 (char *) "self",(char *) "forward", NULL
22238 };
22239
22240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22242 if (SWIG_arg_fail(1)) SWIG_fail;
22243 {
22244 arg2 = (bool)(SWIG_As_bool(obj1));
22245 if (SWIG_arg_fail(2)) SWIG_fail;
22246 }
22247 {
22248 PyThreadState* __tstate = wxPyBeginAllowThreads();
22249 (arg1)->SetDirection(arg2);
22250
22251 wxPyEndAllowThreads(__tstate);
22252 if (PyErr_Occurred()) SWIG_fail;
22253 }
22254 Py_INCREF(Py_None); resultobj = Py_None;
22255 return resultobj;
22256 fail:
22257 return NULL;
22258 }
22259
22260
22261 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22262 PyObject *resultobj;
22263 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22264 bool result;
22265 PyObject * obj0 = 0 ;
22266 char *kwnames[] = {
22267 (char *) "self", NULL
22268 };
22269
22270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22272 if (SWIG_arg_fail(1)) SWIG_fail;
22273 {
22274 PyThreadState* __tstate = wxPyBeginAllowThreads();
22275 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22276
22277 wxPyEndAllowThreads(__tstate);
22278 if (PyErr_Occurred()) SWIG_fail;
22279 }
22280 {
22281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22282 }
22283 return resultobj;
22284 fail:
22285 return NULL;
22286 }
22287
22288
22289 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22290 PyObject *resultobj;
22291 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22292 bool arg2 ;
22293 PyObject * obj0 = 0 ;
22294 PyObject * obj1 = 0 ;
22295 char *kwnames[] = {
22296 (char *) "self",(char *) "ischange", NULL
22297 };
22298
22299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22301 if (SWIG_arg_fail(1)) SWIG_fail;
22302 {
22303 arg2 = (bool)(SWIG_As_bool(obj1));
22304 if (SWIG_arg_fail(2)) SWIG_fail;
22305 }
22306 {
22307 PyThreadState* __tstate = wxPyBeginAllowThreads();
22308 (arg1)->SetWindowChange(arg2);
22309
22310 wxPyEndAllowThreads(__tstate);
22311 if (PyErr_Occurred()) SWIG_fail;
22312 }
22313 Py_INCREF(Py_None); resultobj = Py_None;
22314 return resultobj;
22315 fail:
22316 return NULL;
22317 }
22318
22319
22320 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22321 PyObject *resultobj;
22322 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22323 bool result;
22324 PyObject * obj0 = 0 ;
22325 char *kwnames[] = {
22326 (char *) "self", NULL
22327 };
22328
22329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22331 if (SWIG_arg_fail(1)) SWIG_fail;
22332 {
22333 PyThreadState* __tstate = wxPyBeginAllowThreads();
22334 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22335
22336 wxPyEndAllowThreads(__tstate);
22337 if (PyErr_Occurred()) SWIG_fail;
22338 }
22339 {
22340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22341 }
22342 return resultobj;
22343 fail:
22344 return NULL;
22345 }
22346
22347
22348 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22349 PyObject *resultobj;
22350 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22351 bool arg2 ;
22352 PyObject * obj0 = 0 ;
22353 PyObject * obj1 = 0 ;
22354 char *kwnames[] = {
22355 (char *) "self",(char *) "bIs", NULL
22356 };
22357
22358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22360 if (SWIG_arg_fail(1)) SWIG_fail;
22361 {
22362 arg2 = (bool)(SWIG_As_bool(obj1));
22363 if (SWIG_arg_fail(2)) SWIG_fail;
22364 }
22365 {
22366 PyThreadState* __tstate = wxPyBeginAllowThreads();
22367 (arg1)->SetFromTab(arg2);
22368
22369 wxPyEndAllowThreads(__tstate);
22370 if (PyErr_Occurred()) SWIG_fail;
22371 }
22372 Py_INCREF(Py_None); resultobj = Py_None;
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22380 PyObject *resultobj;
22381 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22382 long arg2 ;
22383 PyObject * obj0 = 0 ;
22384 PyObject * obj1 = 0 ;
22385 char *kwnames[] = {
22386 (char *) "self",(char *) "flags", NULL
22387 };
22388
22389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22391 if (SWIG_arg_fail(1)) SWIG_fail;
22392 {
22393 arg2 = (long)(SWIG_As_long(obj1));
22394 if (SWIG_arg_fail(2)) SWIG_fail;
22395 }
22396 {
22397 PyThreadState* __tstate = wxPyBeginAllowThreads();
22398 (arg1)->SetFlags(arg2);
22399
22400 wxPyEndAllowThreads(__tstate);
22401 if (PyErr_Occurred()) SWIG_fail;
22402 }
22403 Py_INCREF(Py_None); resultobj = Py_None;
22404 return resultobj;
22405 fail:
22406 return NULL;
22407 }
22408
22409
22410 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22411 PyObject *resultobj;
22412 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22413 wxWindow *result;
22414 PyObject * obj0 = 0 ;
22415 char *kwnames[] = {
22416 (char *) "self", NULL
22417 };
22418
22419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22421 if (SWIG_arg_fail(1)) SWIG_fail;
22422 {
22423 PyThreadState* __tstate = wxPyBeginAllowThreads();
22424 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22425
22426 wxPyEndAllowThreads(__tstate);
22427 if (PyErr_Occurred()) SWIG_fail;
22428 }
22429 {
22430 resultobj = wxPyMake_wxObject(result, 0);
22431 }
22432 return resultobj;
22433 fail:
22434 return NULL;
22435 }
22436
22437
22438 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22439 PyObject *resultobj;
22440 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22441 wxWindow *arg2 = (wxWindow *) 0 ;
22442 PyObject * obj0 = 0 ;
22443 PyObject * obj1 = 0 ;
22444 char *kwnames[] = {
22445 (char *) "self",(char *) "win", NULL
22446 };
22447
22448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22450 if (SWIG_arg_fail(1)) SWIG_fail;
22451 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22452 if (SWIG_arg_fail(2)) SWIG_fail;
22453 {
22454 PyThreadState* __tstate = wxPyBeginAllowThreads();
22455 (arg1)->SetCurrentFocus(arg2);
22456
22457 wxPyEndAllowThreads(__tstate);
22458 if (PyErr_Occurred()) SWIG_fail;
22459 }
22460 Py_INCREF(Py_None); resultobj = Py_None;
22461 return resultobj;
22462 fail:
22463 return NULL;
22464 }
22465
22466
22467 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22468 PyObject *obj;
22469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22470 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22471 Py_INCREF(obj);
22472 return Py_BuildValue((char *)"");
22473 }
22474 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22475 PyObject *resultobj;
22476 wxWindow *arg1 = (wxWindow *) NULL ;
22477 wxWindowCreateEvent *result;
22478 PyObject * obj0 = 0 ;
22479 char *kwnames[] = {
22480 (char *) "win", NULL
22481 };
22482
22483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22484 if (obj0) {
22485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22486 if (SWIG_arg_fail(1)) SWIG_fail;
22487 }
22488 {
22489 PyThreadState* __tstate = wxPyBeginAllowThreads();
22490 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22491
22492 wxPyEndAllowThreads(__tstate);
22493 if (PyErr_Occurred()) SWIG_fail;
22494 }
22495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22496 return resultobj;
22497 fail:
22498 return NULL;
22499 }
22500
22501
22502 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22503 PyObject *resultobj;
22504 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22505 wxWindow *result;
22506 PyObject * obj0 = 0 ;
22507 char *kwnames[] = {
22508 (char *) "self", NULL
22509 };
22510
22511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22513 if (SWIG_arg_fail(1)) SWIG_fail;
22514 {
22515 PyThreadState* __tstate = wxPyBeginAllowThreads();
22516 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22517
22518 wxPyEndAllowThreads(__tstate);
22519 if (PyErr_Occurred()) SWIG_fail;
22520 }
22521 {
22522 resultobj = wxPyMake_wxObject(result, 0);
22523 }
22524 return resultobj;
22525 fail:
22526 return NULL;
22527 }
22528
22529
22530 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22531 PyObject *obj;
22532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22533 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22534 Py_INCREF(obj);
22535 return Py_BuildValue((char *)"");
22536 }
22537 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22538 PyObject *resultobj;
22539 wxWindow *arg1 = (wxWindow *) NULL ;
22540 wxWindowDestroyEvent *result;
22541 PyObject * obj0 = 0 ;
22542 char *kwnames[] = {
22543 (char *) "win", NULL
22544 };
22545
22546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22547 if (obj0) {
22548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22549 if (SWIG_arg_fail(1)) SWIG_fail;
22550 }
22551 {
22552 PyThreadState* __tstate = wxPyBeginAllowThreads();
22553 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22554
22555 wxPyEndAllowThreads(__tstate);
22556 if (PyErr_Occurred()) SWIG_fail;
22557 }
22558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22559 return resultobj;
22560 fail:
22561 return NULL;
22562 }
22563
22564
22565 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22566 PyObject *resultobj;
22567 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22568 wxWindow *result;
22569 PyObject * obj0 = 0 ;
22570 char *kwnames[] = {
22571 (char *) "self", NULL
22572 };
22573
22574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22576 if (SWIG_arg_fail(1)) SWIG_fail;
22577 {
22578 PyThreadState* __tstate = wxPyBeginAllowThreads();
22579 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22580
22581 wxPyEndAllowThreads(__tstate);
22582 if (PyErr_Occurred()) SWIG_fail;
22583 }
22584 {
22585 resultobj = wxPyMake_wxObject(result, 0);
22586 }
22587 return resultobj;
22588 fail:
22589 return NULL;
22590 }
22591
22592
22593 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22594 PyObject *obj;
22595 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22596 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22597 Py_INCREF(obj);
22598 return Py_BuildValue((char *)"");
22599 }
22600 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22601 PyObject *resultobj;
22602 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22603 int arg2 = (int) 0 ;
22604 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22605 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22606 wxContextMenuEvent *result;
22607 wxPoint temp3 ;
22608 PyObject * obj0 = 0 ;
22609 PyObject * obj1 = 0 ;
22610 PyObject * obj2 = 0 ;
22611 char *kwnames[] = {
22612 (char *) "type",(char *) "winid",(char *) "pt", NULL
22613 };
22614
22615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22616 if (obj0) {
22617 {
22618 arg1 = (wxEventType)(SWIG_As_int(obj0));
22619 if (SWIG_arg_fail(1)) SWIG_fail;
22620 }
22621 }
22622 if (obj1) {
22623 {
22624 arg2 = (int)(SWIG_As_int(obj1));
22625 if (SWIG_arg_fail(2)) SWIG_fail;
22626 }
22627 }
22628 if (obj2) {
22629 {
22630 arg3 = &temp3;
22631 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22632 }
22633 }
22634 {
22635 PyThreadState* __tstate = wxPyBeginAllowThreads();
22636 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22637
22638 wxPyEndAllowThreads(__tstate);
22639 if (PyErr_Occurred()) SWIG_fail;
22640 }
22641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22642 return resultobj;
22643 fail:
22644 return NULL;
22645 }
22646
22647
22648 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22649 PyObject *resultobj;
22650 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22651 wxPoint *result;
22652 PyObject * obj0 = 0 ;
22653 char *kwnames[] = {
22654 (char *) "self", NULL
22655 };
22656
22657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22659 if (SWIG_arg_fail(1)) SWIG_fail;
22660 {
22661 PyThreadState* __tstate = wxPyBeginAllowThreads();
22662 {
22663 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22664 result = (wxPoint *) &_result_ref;
22665 }
22666
22667 wxPyEndAllowThreads(__tstate);
22668 if (PyErr_Occurred()) SWIG_fail;
22669 }
22670 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22671 return resultobj;
22672 fail:
22673 return NULL;
22674 }
22675
22676
22677 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22678 PyObject *resultobj;
22679 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22680 wxPoint *arg2 = 0 ;
22681 wxPoint temp2 ;
22682 PyObject * obj0 = 0 ;
22683 PyObject * obj1 = 0 ;
22684 char *kwnames[] = {
22685 (char *) "self",(char *) "pos", NULL
22686 };
22687
22688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22690 if (SWIG_arg_fail(1)) SWIG_fail;
22691 {
22692 arg2 = &temp2;
22693 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22694 }
22695 {
22696 PyThreadState* __tstate = wxPyBeginAllowThreads();
22697 (arg1)->SetPosition((wxPoint const &)*arg2);
22698
22699 wxPyEndAllowThreads(__tstate);
22700 if (PyErr_Occurred()) SWIG_fail;
22701 }
22702 Py_INCREF(Py_None); resultobj = Py_None;
22703 return resultobj;
22704 fail:
22705 return NULL;
22706 }
22707
22708
22709 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22710 PyObject *obj;
22711 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22712 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22713 Py_INCREF(obj);
22714 return Py_BuildValue((char *)"");
22715 }
22716 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22717 PyObject *resultobj;
22718 wxIdleEvent *result;
22719 char *kwnames[] = {
22720 NULL
22721 };
22722
22723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22724 {
22725 PyThreadState* __tstate = wxPyBeginAllowThreads();
22726 result = (wxIdleEvent *)new wxIdleEvent();
22727
22728 wxPyEndAllowThreads(__tstate);
22729 if (PyErr_Occurred()) SWIG_fail;
22730 }
22731 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22732 return resultobj;
22733 fail:
22734 return NULL;
22735 }
22736
22737
22738 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22739 PyObject *resultobj;
22740 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22741 bool arg2 = (bool) true ;
22742 PyObject * obj0 = 0 ;
22743 PyObject * obj1 = 0 ;
22744 char *kwnames[] = {
22745 (char *) "self",(char *) "needMore", NULL
22746 };
22747
22748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22750 if (SWIG_arg_fail(1)) SWIG_fail;
22751 if (obj1) {
22752 {
22753 arg2 = (bool)(SWIG_As_bool(obj1));
22754 if (SWIG_arg_fail(2)) SWIG_fail;
22755 }
22756 }
22757 {
22758 PyThreadState* __tstate = wxPyBeginAllowThreads();
22759 (arg1)->RequestMore(arg2);
22760
22761 wxPyEndAllowThreads(__tstate);
22762 if (PyErr_Occurred()) SWIG_fail;
22763 }
22764 Py_INCREF(Py_None); resultobj = Py_None;
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22772 PyObject *resultobj;
22773 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22774 bool result;
22775 PyObject * obj0 = 0 ;
22776 char *kwnames[] = {
22777 (char *) "self", NULL
22778 };
22779
22780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22782 if (SWIG_arg_fail(1)) SWIG_fail;
22783 {
22784 PyThreadState* __tstate = wxPyBeginAllowThreads();
22785 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22786
22787 wxPyEndAllowThreads(__tstate);
22788 if (PyErr_Occurred()) SWIG_fail;
22789 }
22790 {
22791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22792 }
22793 return resultobj;
22794 fail:
22795 return NULL;
22796 }
22797
22798
22799 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22800 PyObject *resultobj;
22801 wxIdleMode arg1 ;
22802 PyObject * obj0 = 0 ;
22803 char *kwnames[] = {
22804 (char *) "mode", NULL
22805 };
22806
22807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22808 {
22809 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22810 if (SWIG_arg_fail(1)) SWIG_fail;
22811 }
22812 {
22813 PyThreadState* __tstate = wxPyBeginAllowThreads();
22814 wxIdleEvent::SetMode((wxIdleMode )arg1);
22815
22816 wxPyEndAllowThreads(__tstate);
22817 if (PyErr_Occurred()) SWIG_fail;
22818 }
22819 Py_INCREF(Py_None); resultobj = Py_None;
22820 return resultobj;
22821 fail:
22822 return NULL;
22823 }
22824
22825
22826 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22827 PyObject *resultobj;
22828 wxIdleMode result;
22829 char *kwnames[] = {
22830 NULL
22831 };
22832
22833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22834 {
22835 PyThreadState* __tstate = wxPyBeginAllowThreads();
22836 result = (wxIdleMode)wxIdleEvent::GetMode();
22837
22838 wxPyEndAllowThreads(__tstate);
22839 if (PyErr_Occurred()) SWIG_fail;
22840 }
22841 resultobj = SWIG_From_int((result));
22842 return resultobj;
22843 fail:
22844 return NULL;
22845 }
22846
22847
22848 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22849 PyObject *resultobj;
22850 wxWindow *arg1 = (wxWindow *) 0 ;
22851 bool result;
22852 PyObject * obj0 = 0 ;
22853 char *kwnames[] = {
22854 (char *) "win", NULL
22855 };
22856
22857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22859 if (SWIG_arg_fail(1)) SWIG_fail;
22860 {
22861 PyThreadState* __tstate = wxPyBeginAllowThreads();
22862 result = (bool)wxIdleEvent::CanSend(arg1);
22863
22864 wxPyEndAllowThreads(__tstate);
22865 if (PyErr_Occurred()) SWIG_fail;
22866 }
22867 {
22868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22869 }
22870 return resultobj;
22871 fail:
22872 return NULL;
22873 }
22874
22875
22876 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22877 PyObject *obj;
22878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22879 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22880 Py_INCREF(obj);
22881 return Py_BuildValue((char *)"");
22882 }
22883 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22884 PyObject *resultobj;
22885 int arg1 = (int) 0 ;
22886 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22887 wxPyEvent *result;
22888 PyObject * obj0 = 0 ;
22889 PyObject * obj1 = 0 ;
22890 char *kwnames[] = {
22891 (char *) "winid",(char *) "eventType", NULL
22892 };
22893
22894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22895 if (obj0) {
22896 {
22897 arg1 = (int)(SWIG_As_int(obj0));
22898 if (SWIG_arg_fail(1)) SWIG_fail;
22899 }
22900 }
22901 if (obj1) {
22902 {
22903 arg2 = (wxEventType)(SWIG_As_int(obj1));
22904 if (SWIG_arg_fail(2)) SWIG_fail;
22905 }
22906 }
22907 {
22908 PyThreadState* __tstate = wxPyBeginAllowThreads();
22909 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22910
22911 wxPyEndAllowThreads(__tstate);
22912 if (PyErr_Occurred()) SWIG_fail;
22913 }
22914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22915 return resultobj;
22916 fail:
22917 return NULL;
22918 }
22919
22920
22921 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22922 PyObject *resultobj;
22923 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22924 PyObject * obj0 = 0 ;
22925 char *kwnames[] = {
22926 (char *) "self", NULL
22927 };
22928
22929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22931 if (SWIG_arg_fail(1)) SWIG_fail;
22932 {
22933 PyThreadState* __tstate = wxPyBeginAllowThreads();
22934 delete arg1;
22935
22936 wxPyEndAllowThreads(__tstate);
22937 if (PyErr_Occurred()) SWIG_fail;
22938 }
22939 Py_INCREF(Py_None); resultobj = Py_None;
22940 return resultobj;
22941 fail:
22942 return NULL;
22943 }
22944
22945
22946 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22947 PyObject *resultobj;
22948 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22949 PyObject *arg2 = (PyObject *) 0 ;
22950 PyObject * obj0 = 0 ;
22951 PyObject * obj1 = 0 ;
22952 char *kwnames[] = {
22953 (char *) "self",(char *) "self", NULL
22954 };
22955
22956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22958 if (SWIG_arg_fail(1)) SWIG_fail;
22959 arg2 = obj1;
22960 {
22961 PyThreadState* __tstate = wxPyBeginAllowThreads();
22962 (arg1)->SetSelf(arg2);
22963
22964 wxPyEndAllowThreads(__tstate);
22965 if (PyErr_Occurred()) SWIG_fail;
22966 }
22967 Py_INCREF(Py_None); resultobj = Py_None;
22968 return resultobj;
22969 fail:
22970 return NULL;
22971 }
22972
22973
22974 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22975 PyObject *resultobj;
22976 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22977 PyObject *result;
22978 PyObject * obj0 = 0 ;
22979 char *kwnames[] = {
22980 (char *) "self", NULL
22981 };
22982
22983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
22984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22985 if (SWIG_arg_fail(1)) SWIG_fail;
22986 {
22987 PyThreadState* __tstate = wxPyBeginAllowThreads();
22988 result = (PyObject *)(arg1)->GetSelf();
22989
22990 wxPyEndAllowThreads(__tstate);
22991 if (PyErr_Occurred()) SWIG_fail;
22992 }
22993 resultobj = result;
22994 return resultobj;
22995 fail:
22996 return NULL;
22997 }
22998
22999
23000 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
23001 PyObject *obj;
23002 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23003 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
23004 Py_INCREF(obj);
23005 return Py_BuildValue((char *)"");
23006 }
23007 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23008 PyObject *resultobj;
23009 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23010 int arg2 = (int) 0 ;
23011 wxPyCommandEvent *result;
23012 PyObject * obj0 = 0 ;
23013 PyObject * obj1 = 0 ;
23014 char *kwnames[] = {
23015 (char *) "eventType",(char *) "id", NULL
23016 };
23017
23018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
23019 if (obj0) {
23020 {
23021 arg1 = (wxEventType)(SWIG_As_int(obj0));
23022 if (SWIG_arg_fail(1)) SWIG_fail;
23023 }
23024 }
23025 if (obj1) {
23026 {
23027 arg2 = (int)(SWIG_As_int(obj1));
23028 if (SWIG_arg_fail(2)) SWIG_fail;
23029 }
23030 }
23031 {
23032 PyThreadState* __tstate = wxPyBeginAllowThreads();
23033 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23034
23035 wxPyEndAllowThreads(__tstate);
23036 if (PyErr_Occurred()) SWIG_fail;
23037 }
23038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23039 return resultobj;
23040 fail:
23041 return NULL;
23042 }
23043
23044
23045 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23046 PyObject *resultobj;
23047 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23048 PyObject * obj0 = 0 ;
23049 char *kwnames[] = {
23050 (char *) "self", NULL
23051 };
23052
23053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23055 if (SWIG_arg_fail(1)) SWIG_fail;
23056 {
23057 PyThreadState* __tstate = wxPyBeginAllowThreads();
23058 delete arg1;
23059
23060 wxPyEndAllowThreads(__tstate);
23061 if (PyErr_Occurred()) SWIG_fail;
23062 }
23063 Py_INCREF(Py_None); resultobj = Py_None;
23064 return resultobj;
23065 fail:
23066 return NULL;
23067 }
23068
23069
23070 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23071 PyObject *resultobj;
23072 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23073 PyObject *arg2 = (PyObject *) 0 ;
23074 PyObject * obj0 = 0 ;
23075 PyObject * obj1 = 0 ;
23076 char *kwnames[] = {
23077 (char *) "self",(char *) "self", NULL
23078 };
23079
23080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23082 if (SWIG_arg_fail(1)) SWIG_fail;
23083 arg2 = obj1;
23084 {
23085 PyThreadState* __tstate = wxPyBeginAllowThreads();
23086 (arg1)->SetSelf(arg2);
23087
23088 wxPyEndAllowThreads(__tstate);
23089 if (PyErr_Occurred()) SWIG_fail;
23090 }
23091 Py_INCREF(Py_None); resultobj = Py_None;
23092 return resultobj;
23093 fail:
23094 return NULL;
23095 }
23096
23097
23098 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23099 PyObject *resultobj;
23100 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23101 PyObject *result;
23102 PyObject * obj0 = 0 ;
23103 char *kwnames[] = {
23104 (char *) "self", NULL
23105 };
23106
23107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23109 if (SWIG_arg_fail(1)) SWIG_fail;
23110 {
23111 PyThreadState* __tstate = wxPyBeginAllowThreads();
23112 result = (PyObject *)(arg1)->GetSelf();
23113
23114 wxPyEndAllowThreads(__tstate);
23115 if (PyErr_Occurred()) SWIG_fail;
23116 }
23117 resultobj = result;
23118 return resultobj;
23119 fail:
23120 return NULL;
23121 }
23122
23123
23124 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23125 PyObject *obj;
23126 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23127 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23128 Py_INCREF(obj);
23129 return Py_BuildValue((char *)"");
23130 }
23131 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23132 PyObject *resultobj;
23133 wxWindow *arg1 = (wxWindow *) 0 ;
23134 wxDateTime *arg2 = 0 ;
23135 wxEventType arg3 ;
23136 wxDateEvent *result;
23137 PyObject * obj0 = 0 ;
23138 PyObject * obj1 = 0 ;
23139 PyObject * obj2 = 0 ;
23140 char *kwnames[] = {
23141 (char *) "win",(char *) "dt",(char *) "type", NULL
23142 };
23143
23144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23146 if (SWIG_arg_fail(1)) SWIG_fail;
23147 {
23148 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23149 if (SWIG_arg_fail(2)) SWIG_fail;
23150 if (arg2 == NULL) {
23151 SWIG_null_ref("wxDateTime");
23152 }
23153 if (SWIG_arg_fail(2)) SWIG_fail;
23154 }
23155 {
23156 arg3 = (wxEventType)(SWIG_As_int(obj2));
23157 if (SWIG_arg_fail(3)) SWIG_fail;
23158 }
23159 {
23160 PyThreadState* __tstate = wxPyBeginAllowThreads();
23161 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23162
23163 wxPyEndAllowThreads(__tstate);
23164 if (PyErr_Occurred()) SWIG_fail;
23165 }
23166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23167 return resultobj;
23168 fail:
23169 return NULL;
23170 }
23171
23172
23173 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23174 PyObject *resultobj;
23175 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23176 wxDateTime *result;
23177 PyObject * obj0 = 0 ;
23178 char *kwnames[] = {
23179 (char *) "self", NULL
23180 };
23181
23182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23184 if (SWIG_arg_fail(1)) SWIG_fail;
23185 {
23186 PyThreadState* __tstate = wxPyBeginAllowThreads();
23187 {
23188 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23189 result = (wxDateTime *) &_result_ref;
23190 }
23191
23192 wxPyEndAllowThreads(__tstate);
23193 if (PyErr_Occurred()) SWIG_fail;
23194 }
23195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23203 PyObject *resultobj;
23204 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23205 wxDateTime *arg2 = 0 ;
23206 PyObject * obj0 = 0 ;
23207 PyObject * obj1 = 0 ;
23208 char *kwnames[] = {
23209 (char *) "self",(char *) "date", NULL
23210 };
23211
23212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23214 if (SWIG_arg_fail(1)) SWIG_fail;
23215 {
23216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23217 if (SWIG_arg_fail(2)) SWIG_fail;
23218 if (arg2 == NULL) {
23219 SWIG_null_ref("wxDateTime");
23220 }
23221 if (SWIG_arg_fail(2)) SWIG_fail;
23222 }
23223 {
23224 PyThreadState* __tstate = wxPyBeginAllowThreads();
23225 (arg1)->SetDate((wxDateTime const &)*arg2);
23226
23227 wxPyEndAllowThreads(__tstate);
23228 if (PyErr_Occurred()) SWIG_fail;
23229 }
23230 Py_INCREF(Py_None); resultobj = Py_None;
23231 return resultobj;
23232 fail:
23233 return NULL;
23234 }
23235
23236
23237 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23238 PyObject *obj;
23239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23240 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23241 Py_INCREF(obj);
23242 return Py_BuildValue((char *)"");
23243 }
23244 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23245 PyObject *resultobj;
23246 wxPyApp *result;
23247 char *kwnames[] = {
23248 NULL
23249 };
23250
23251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23252 {
23253 PyThreadState* __tstate = wxPyBeginAllowThreads();
23254 result = (wxPyApp *)new_wxPyApp();
23255
23256 wxPyEndAllowThreads(__tstate);
23257 if (PyErr_Occurred()) SWIG_fail;
23258 }
23259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23260 return resultobj;
23261 fail:
23262 return NULL;
23263 }
23264
23265
23266 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23267 PyObject *resultobj;
23268 wxPyApp *arg1 = (wxPyApp *) 0 ;
23269 PyObject * obj0 = 0 ;
23270 char *kwnames[] = {
23271 (char *) "self", NULL
23272 };
23273
23274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23276 if (SWIG_arg_fail(1)) SWIG_fail;
23277 {
23278 PyThreadState* __tstate = wxPyBeginAllowThreads();
23279 delete arg1;
23280
23281 wxPyEndAllowThreads(__tstate);
23282 if (PyErr_Occurred()) SWIG_fail;
23283 }
23284 Py_INCREF(Py_None); resultobj = Py_None;
23285 return resultobj;
23286 fail:
23287 return NULL;
23288 }
23289
23290
23291 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23292 PyObject *resultobj;
23293 wxPyApp *arg1 = (wxPyApp *) 0 ;
23294 PyObject *arg2 = (PyObject *) 0 ;
23295 PyObject *arg3 = (PyObject *) 0 ;
23296 bool arg4 ;
23297 PyObject * obj0 = 0 ;
23298 PyObject * obj1 = 0 ;
23299 PyObject * obj2 = 0 ;
23300 PyObject * obj3 = 0 ;
23301 char *kwnames[] = {
23302 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23303 };
23304
23305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23307 if (SWIG_arg_fail(1)) SWIG_fail;
23308 arg2 = obj1;
23309 arg3 = obj2;
23310 {
23311 arg4 = (bool)(SWIG_As_bool(obj3));
23312 if (SWIG_arg_fail(4)) SWIG_fail;
23313 }
23314 {
23315 PyThreadState* __tstate = wxPyBeginAllowThreads();
23316 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23317
23318 wxPyEndAllowThreads(__tstate);
23319 if (PyErr_Occurred()) SWIG_fail;
23320 }
23321 Py_INCREF(Py_None); resultobj = Py_None;
23322 return resultobj;
23323 fail:
23324 return NULL;
23325 }
23326
23327
23328 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23329 PyObject *resultobj;
23330 wxPyApp *arg1 = (wxPyApp *) 0 ;
23331 wxString result;
23332 PyObject * obj0 = 0 ;
23333 char *kwnames[] = {
23334 (char *) "self", NULL
23335 };
23336
23337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23339 if (SWIG_arg_fail(1)) SWIG_fail;
23340 {
23341 PyThreadState* __tstate = wxPyBeginAllowThreads();
23342 result = ((wxPyApp const *)arg1)->GetAppName();
23343
23344 wxPyEndAllowThreads(__tstate);
23345 if (PyErr_Occurred()) SWIG_fail;
23346 }
23347 {
23348 #if wxUSE_UNICODE
23349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23350 #else
23351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23352 #endif
23353 }
23354 return resultobj;
23355 fail:
23356 return NULL;
23357 }
23358
23359
23360 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23361 PyObject *resultobj;
23362 wxPyApp *arg1 = (wxPyApp *) 0 ;
23363 wxString *arg2 = 0 ;
23364 bool temp2 = false ;
23365 PyObject * obj0 = 0 ;
23366 PyObject * obj1 = 0 ;
23367 char *kwnames[] = {
23368 (char *) "self",(char *) "name", NULL
23369 };
23370
23371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23373 if (SWIG_arg_fail(1)) SWIG_fail;
23374 {
23375 arg2 = wxString_in_helper(obj1);
23376 if (arg2 == NULL) SWIG_fail;
23377 temp2 = true;
23378 }
23379 {
23380 PyThreadState* __tstate = wxPyBeginAllowThreads();
23381 (arg1)->SetAppName((wxString const &)*arg2);
23382
23383 wxPyEndAllowThreads(__tstate);
23384 if (PyErr_Occurred()) SWIG_fail;
23385 }
23386 Py_INCREF(Py_None); resultobj = Py_None;
23387 {
23388 if (temp2)
23389 delete arg2;
23390 }
23391 return resultobj;
23392 fail:
23393 {
23394 if (temp2)
23395 delete arg2;
23396 }
23397 return NULL;
23398 }
23399
23400
23401 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23402 PyObject *resultobj;
23403 wxPyApp *arg1 = (wxPyApp *) 0 ;
23404 wxString result;
23405 PyObject * obj0 = 0 ;
23406 char *kwnames[] = {
23407 (char *) "self", NULL
23408 };
23409
23410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23412 if (SWIG_arg_fail(1)) SWIG_fail;
23413 {
23414 PyThreadState* __tstate = wxPyBeginAllowThreads();
23415 result = ((wxPyApp const *)arg1)->GetClassName();
23416
23417 wxPyEndAllowThreads(__tstate);
23418 if (PyErr_Occurred()) SWIG_fail;
23419 }
23420 {
23421 #if wxUSE_UNICODE
23422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23423 #else
23424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23425 #endif
23426 }
23427 return resultobj;
23428 fail:
23429 return NULL;
23430 }
23431
23432
23433 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23434 PyObject *resultobj;
23435 wxPyApp *arg1 = (wxPyApp *) 0 ;
23436 wxString *arg2 = 0 ;
23437 bool temp2 = false ;
23438 PyObject * obj0 = 0 ;
23439 PyObject * obj1 = 0 ;
23440 char *kwnames[] = {
23441 (char *) "self",(char *) "name", NULL
23442 };
23443
23444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23446 if (SWIG_arg_fail(1)) SWIG_fail;
23447 {
23448 arg2 = wxString_in_helper(obj1);
23449 if (arg2 == NULL) SWIG_fail;
23450 temp2 = true;
23451 }
23452 {
23453 PyThreadState* __tstate = wxPyBeginAllowThreads();
23454 (arg1)->SetClassName((wxString const &)*arg2);
23455
23456 wxPyEndAllowThreads(__tstate);
23457 if (PyErr_Occurred()) SWIG_fail;
23458 }
23459 Py_INCREF(Py_None); resultobj = Py_None;
23460 {
23461 if (temp2)
23462 delete arg2;
23463 }
23464 return resultobj;
23465 fail:
23466 {
23467 if (temp2)
23468 delete arg2;
23469 }
23470 return NULL;
23471 }
23472
23473
23474 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23475 PyObject *resultobj;
23476 wxPyApp *arg1 = (wxPyApp *) 0 ;
23477 wxString *result;
23478 PyObject * obj0 = 0 ;
23479 char *kwnames[] = {
23480 (char *) "self", NULL
23481 };
23482
23483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23485 if (SWIG_arg_fail(1)) SWIG_fail;
23486 {
23487 PyThreadState* __tstate = wxPyBeginAllowThreads();
23488 {
23489 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23490 result = (wxString *) &_result_ref;
23491 }
23492
23493 wxPyEndAllowThreads(__tstate);
23494 if (PyErr_Occurred()) SWIG_fail;
23495 }
23496 {
23497 #if wxUSE_UNICODE
23498 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23499 #else
23500 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23501 #endif
23502 }
23503 return resultobj;
23504 fail:
23505 return NULL;
23506 }
23507
23508
23509 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23510 PyObject *resultobj;
23511 wxPyApp *arg1 = (wxPyApp *) 0 ;
23512 wxString *arg2 = 0 ;
23513 bool temp2 = false ;
23514 PyObject * obj0 = 0 ;
23515 PyObject * obj1 = 0 ;
23516 char *kwnames[] = {
23517 (char *) "self",(char *) "name", NULL
23518 };
23519
23520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23522 if (SWIG_arg_fail(1)) SWIG_fail;
23523 {
23524 arg2 = wxString_in_helper(obj1);
23525 if (arg2 == NULL) SWIG_fail;
23526 temp2 = true;
23527 }
23528 {
23529 PyThreadState* __tstate = wxPyBeginAllowThreads();
23530 (arg1)->SetVendorName((wxString const &)*arg2);
23531
23532 wxPyEndAllowThreads(__tstate);
23533 if (PyErr_Occurred()) SWIG_fail;
23534 }
23535 Py_INCREF(Py_None); resultobj = Py_None;
23536 {
23537 if (temp2)
23538 delete arg2;
23539 }
23540 return resultobj;
23541 fail:
23542 {
23543 if (temp2)
23544 delete arg2;
23545 }
23546 return NULL;
23547 }
23548
23549
23550 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23551 PyObject *resultobj;
23552 wxPyApp *arg1 = (wxPyApp *) 0 ;
23553 wxAppTraits *result;
23554 PyObject * obj0 = 0 ;
23555 char *kwnames[] = {
23556 (char *) "self", NULL
23557 };
23558
23559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23561 if (SWIG_arg_fail(1)) SWIG_fail;
23562 {
23563 PyThreadState* __tstate = wxPyBeginAllowThreads();
23564 result = (wxAppTraits *)(arg1)->GetTraits();
23565
23566 wxPyEndAllowThreads(__tstate);
23567 if (PyErr_Occurred()) SWIG_fail;
23568 }
23569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23570 return resultobj;
23571 fail:
23572 return NULL;
23573 }
23574
23575
23576 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23577 PyObject *resultobj;
23578 wxPyApp *arg1 = (wxPyApp *) 0 ;
23579 PyObject * obj0 = 0 ;
23580 char *kwnames[] = {
23581 (char *) "self", NULL
23582 };
23583
23584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23586 if (SWIG_arg_fail(1)) SWIG_fail;
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 (arg1)->ProcessPendingEvents();
23590
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 Py_INCREF(Py_None); resultobj = Py_None;
23595 return resultobj;
23596 fail:
23597 return NULL;
23598 }
23599
23600
23601 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23602 PyObject *resultobj;
23603 wxPyApp *arg1 = (wxPyApp *) 0 ;
23604 bool arg2 = (bool) false ;
23605 bool result;
23606 PyObject * obj0 = 0 ;
23607 PyObject * obj1 = 0 ;
23608 char *kwnames[] = {
23609 (char *) "self",(char *) "onlyIfNeeded", NULL
23610 };
23611
23612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23614 if (SWIG_arg_fail(1)) SWIG_fail;
23615 if (obj1) {
23616 {
23617 arg2 = (bool)(SWIG_As_bool(obj1));
23618 if (SWIG_arg_fail(2)) SWIG_fail;
23619 }
23620 }
23621 {
23622 PyThreadState* __tstate = wxPyBeginAllowThreads();
23623 result = (bool)(arg1)->Yield(arg2);
23624
23625 wxPyEndAllowThreads(__tstate);
23626 if (PyErr_Occurred()) SWIG_fail;
23627 }
23628 {
23629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23630 }
23631 return resultobj;
23632 fail:
23633 return NULL;
23634 }
23635
23636
23637 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23638 PyObject *resultobj;
23639 wxPyApp *arg1 = (wxPyApp *) 0 ;
23640 PyObject * obj0 = 0 ;
23641 char *kwnames[] = {
23642 (char *) "self", NULL
23643 };
23644
23645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23647 if (SWIG_arg_fail(1)) SWIG_fail;
23648 {
23649 PyThreadState* __tstate = wxPyBeginAllowThreads();
23650 (arg1)->WakeUpIdle();
23651
23652 wxPyEndAllowThreads(__tstate);
23653 if (PyErr_Occurred()) SWIG_fail;
23654 }
23655 Py_INCREF(Py_None); resultobj = Py_None;
23656 return resultobj;
23657 fail:
23658 return NULL;
23659 }
23660
23661
23662 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23663 PyObject *resultobj;
23664 bool result;
23665 char *kwnames[] = {
23666 NULL
23667 };
23668
23669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23670 {
23671 PyThreadState* __tstate = wxPyBeginAllowThreads();
23672 result = (bool)wxPyApp::IsMainLoopRunning();
23673
23674 wxPyEndAllowThreads(__tstate);
23675 if (PyErr_Occurred()) SWIG_fail;
23676 }
23677 {
23678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23679 }
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23687 PyObject *resultobj;
23688 wxPyApp *arg1 = (wxPyApp *) 0 ;
23689 int result;
23690 PyObject * obj0 = 0 ;
23691 char *kwnames[] = {
23692 (char *) "self", NULL
23693 };
23694
23695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23697 if (SWIG_arg_fail(1)) SWIG_fail;
23698 {
23699 PyThreadState* __tstate = wxPyBeginAllowThreads();
23700 result = (int)(arg1)->MainLoop();
23701
23702 wxPyEndAllowThreads(__tstate);
23703 if (PyErr_Occurred()) SWIG_fail;
23704 }
23705 {
23706 resultobj = SWIG_From_int((int)(result));
23707 }
23708 return resultobj;
23709 fail:
23710 return NULL;
23711 }
23712
23713
23714 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23715 PyObject *resultobj;
23716 wxPyApp *arg1 = (wxPyApp *) 0 ;
23717 PyObject * obj0 = 0 ;
23718 char *kwnames[] = {
23719 (char *) "self", NULL
23720 };
23721
23722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23724 if (SWIG_arg_fail(1)) SWIG_fail;
23725 {
23726 PyThreadState* __tstate = wxPyBeginAllowThreads();
23727 (arg1)->Exit();
23728
23729 wxPyEndAllowThreads(__tstate);
23730 if (PyErr_Occurred()) SWIG_fail;
23731 }
23732 Py_INCREF(Py_None); resultobj = Py_None;
23733 return resultobj;
23734 fail:
23735 return NULL;
23736 }
23737
23738
23739 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23740 PyObject *resultobj;
23741 wxPyApp *arg1 = (wxPyApp *) 0 ;
23742 PyObject * obj0 = 0 ;
23743 char *kwnames[] = {
23744 (char *) "self", NULL
23745 };
23746
23747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23749 if (SWIG_arg_fail(1)) SWIG_fail;
23750 {
23751 PyThreadState* __tstate = wxPyBeginAllowThreads();
23752 (arg1)->ExitMainLoop();
23753
23754 wxPyEndAllowThreads(__tstate);
23755 if (PyErr_Occurred()) SWIG_fail;
23756 }
23757 Py_INCREF(Py_None); resultobj = Py_None;
23758 return resultobj;
23759 fail:
23760 return NULL;
23761 }
23762
23763
23764 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23765 PyObject *resultobj;
23766 wxPyApp *arg1 = (wxPyApp *) 0 ;
23767 bool result;
23768 PyObject * obj0 = 0 ;
23769 char *kwnames[] = {
23770 (char *) "self", NULL
23771 };
23772
23773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23775 if (SWIG_arg_fail(1)) SWIG_fail;
23776 {
23777 PyThreadState* __tstate = wxPyBeginAllowThreads();
23778 result = (bool)(arg1)->Pending();
23779
23780 wxPyEndAllowThreads(__tstate);
23781 if (PyErr_Occurred()) SWIG_fail;
23782 }
23783 {
23784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23785 }
23786 return resultobj;
23787 fail:
23788 return NULL;
23789 }
23790
23791
23792 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23793 PyObject *resultobj;
23794 wxPyApp *arg1 = (wxPyApp *) 0 ;
23795 bool result;
23796 PyObject * obj0 = 0 ;
23797 char *kwnames[] = {
23798 (char *) "self", NULL
23799 };
23800
23801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23803 if (SWIG_arg_fail(1)) SWIG_fail;
23804 {
23805 PyThreadState* __tstate = wxPyBeginAllowThreads();
23806 result = (bool)(arg1)->Dispatch();
23807
23808 wxPyEndAllowThreads(__tstate);
23809 if (PyErr_Occurred()) SWIG_fail;
23810 }
23811 {
23812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23813 }
23814 return resultobj;
23815 fail:
23816 return NULL;
23817 }
23818
23819
23820 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23821 PyObject *resultobj;
23822 wxPyApp *arg1 = (wxPyApp *) 0 ;
23823 bool result;
23824 PyObject * obj0 = 0 ;
23825 char *kwnames[] = {
23826 (char *) "self", NULL
23827 };
23828
23829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23831 if (SWIG_arg_fail(1)) SWIG_fail;
23832 {
23833 PyThreadState* __tstate = wxPyBeginAllowThreads();
23834 result = (bool)(arg1)->ProcessIdle();
23835
23836 wxPyEndAllowThreads(__tstate);
23837 if (PyErr_Occurred()) SWIG_fail;
23838 }
23839 {
23840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23841 }
23842 return resultobj;
23843 fail:
23844 return NULL;
23845 }
23846
23847
23848 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23849 PyObject *resultobj;
23850 wxPyApp *arg1 = (wxPyApp *) 0 ;
23851 wxWindow *arg2 = (wxWindow *) 0 ;
23852 wxIdleEvent *arg3 = 0 ;
23853 bool result;
23854 PyObject * obj0 = 0 ;
23855 PyObject * obj1 = 0 ;
23856 PyObject * obj2 = 0 ;
23857 char *kwnames[] = {
23858 (char *) "self",(char *) "win",(char *) "event", NULL
23859 };
23860
23861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23863 if (SWIG_arg_fail(1)) SWIG_fail;
23864 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23865 if (SWIG_arg_fail(2)) SWIG_fail;
23866 {
23867 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23868 if (SWIG_arg_fail(3)) SWIG_fail;
23869 if (arg3 == NULL) {
23870 SWIG_null_ref("wxIdleEvent");
23871 }
23872 if (SWIG_arg_fail(3)) SWIG_fail;
23873 }
23874 {
23875 PyThreadState* __tstate = wxPyBeginAllowThreads();
23876 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23877
23878 wxPyEndAllowThreads(__tstate);
23879 if (PyErr_Occurred()) SWIG_fail;
23880 }
23881 {
23882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23883 }
23884 return resultobj;
23885 fail:
23886 return NULL;
23887 }
23888
23889
23890 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23891 PyObject *resultobj;
23892 wxPyApp *arg1 = (wxPyApp *) 0 ;
23893 bool result;
23894 PyObject * obj0 = 0 ;
23895 char *kwnames[] = {
23896 (char *) "self", NULL
23897 };
23898
23899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23901 if (SWIG_arg_fail(1)) SWIG_fail;
23902 {
23903 PyThreadState* __tstate = wxPyBeginAllowThreads();
23904 result = (bool)((wxPyApp const *)arg1)->IsActive();
23905
23906 wxPyEndAllowThreads(__tstate);
23907 if (PyErr_Occurred()) SWIG_fail;
23908 }
23909 {
23910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23911 }
23912 return resultobj;
23913 fail:
23914 return NULL;
23915 }
23916
23917
23918 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23919 PyObject *resultobj;
23920 wxPyApp *arg1 = (wxPyApp *) 0 ;
23921 wxWindow *arg2 = (wxWindow *) 0 ;
23922 PyObject * obj0 = 0 ;
23923 PyObject * obj1 = 0 ;
23924 char *kwnames[] = {
23925 (char *) "self",(char *) "win", NULL
23926 };
23927
23928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23930 if (SWIG_arg_fail(1)) SWIG_fail;
23931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23932 if (SWIG_arg_fail(2)) SWIG_fail;
23933 {
23934 PyThreadState* __tstate = wxPyBeginAllowThreads();
23935 (arg1)->SetTopWindow(arg2);
23936
23937 wxPyEndAllowThreads(__tstate);
23938 if (PyErr_Occurred()) SWIG_fail;
23939 }
23940 Py_INCREF(Py_None); resultobj = Py_None;
23941 return resultobj;
23942 fail:
23943 return NULL;
23944 }
23945
23946
23947 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23948 PyObject *resultobj;
23949 wxPyApp *arg1 = (wxPyApp *) 0 ;
23950 wxWindow *result;
23951 PyObject * obj0 = 0 ;
23952 char *kwnames[] = {
23953 (char *) "self", NULL
23954 };
23955
23956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23958 if (SWIG_arg_fail(1)) SWIG_fail;
23959 {
23960 PyThreadState* __tstate = wxPyBeginAllowThreads();
23961 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23962
23963 wxPyEndAllowThreads(__tstate);
23964 if (PyErr_Occurred()) SWIG_fail;
23965 }
23966 {
23967 resultobj = wxPyMake_wxObject(result, 0);
23968 }
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23976 PyObject *resultobj;
23977 wxPyApp *arg1 = (wxPyApp *) 0 ;
23978 bool arg2 ;
23979 PyObject * obj0 = 0 ;
23980 PyObject * obj1 = 0 ;
23981 char *kwnames[] = {
23982 (char *) "self",(char *) "flag", NULL
23983 };
23984
23985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23987 if (SWIG_arg_fail(1)) SWIG_fail;
23988 {
23989 arg2 = (bool)(SWIG_As_bool(obj1));
23990 if (SWIG_arg_fail(2)) SWIG_fail;
23991 }
23992 {
23993 PyThreadState* __tstate = wxPyBeginAllowThreads();
23994 (arg1)->SetExitOnFrameDelete(arg2);
23995
23996 wxPyEndAllowThreads(__tstate);
23997 if (PyErr_Occurred()) SWIG_fail;
23998 }
23999 Py_INCREF(Py_None); resultobj = Py_None;
24000 return resultobj;
24001 fail:
24002 return NULL;
24003 }
24004
24005
24006 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24007 PyObject *resultobj;
24008 wxPyApp *arg1 = (wxPyApp *) 0 ;
24009 bool result;
24010 PyObject * obj0 = 0 ;
24011 char *kwnames[] = {
24012 (char *) "self", NULL
24013 };
24014
24015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
24016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24017 if (SWIG_arg_fail(1)) SWIG_fail;
24018 {
24019 PyThreadState* __tstate = wxPyBeginAllowThreads();
24020 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
24021
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 {
24026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24027 }
24028 return resultobj;
24029 fail:
24030 return NULL;
24031 }
24032
24033
24034 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24035 PyObject *resultobj;
24036 wxPyApp *arg1 = (wxPyApp *) 0 ;
24037 bool arg2 ;
24038 PyObject * obj0 = 0 ;
24039 PyObject * obj1 = 0 ;
24040 char *kwnames[] = {
24041 (char *) "self",(char *) "flag", NULL
24042 };
24043
24044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24046 if (SWIG_arg_fail(1)) SWIG_fail;
24047 {
24048 arg2 = (bool)(SWIG_As_bool(obj1));
24049 if (SWIG_arg_fail(2)) SWIG_fail;
24050 }
24051 {
24052 PyThreadState* __tstate = wxPyBeginAllowThreads();
24053 (arg1)->SetUseBestVisual(arg2);
24054
24055 wxPyEndAllowThreads(__tstate);
24056 if (PyErr_Occurred()) SWIG_fail;
24057 }
24058 Py_INCREF(Py_None); resultobj = Py_None;
24059 return resultobj;
24060 fail:
24061 return NULL;
24062 }
24063
24064
24065 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24066 PyObject *resultobj;
24067 wxPyApp *arg1 = (wxPyApp *) 0 ;
24068 bool result;
24069 PyObject * obj0 = 0 ;
24070 char *kwnames[] = {
24071 (char *) "self", NULL
24072 };
24073
24074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24076 if (SWIG_arg_fail(1)) SWIG_fail;
24077 {
24078 PyThreadState* __tstate = wxPyBeginAllowThreads();
24079 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24080
24081 wxPyEndAllowThreads(__tstate);
24082 if (PyErr_Occurred()) SWIG_fail;
24083 }
24084 {
24085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24086 }
24087 return resultobj;
24088 fail:
24089 return NULL;
24090 }
24091
24092
24093 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24094 PyObject *resultobj;
24095 wxPyApp *arg1 = (wxPyApp *) 0 ;
24096 int arg2 ;
24097 PyObject * obj0 = 0 ;
24098 PyObject * obj1 = 0 ;
24099 char *kwnames[] = {
24100 (char *) "self",(char *) "mode", NULL
24101 };
24102
24103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24105 if (SWIG_arg_fail(1)) SWIG_fail;
24106 {
24107 arg2 = (int)(SWIG_As_int(obj1));
24108 if (SWIG_arg_fail(2)) SWIG_fail;
24109 }
24110 {
24111 PyThreadState* __tstate = wxPyBeginAllowThreads();
24112 (arg1)->SetPrintMode(arg2);
24113
24114 wxPyEndAllowThreads(__tstate);
24115 if (PyErr_Occurred()) SWIG_fail;
24116 }
24117 Py_INCREF(Py_None); resultobj = Py_None;
24118 return resultobj;
24119 fail:
24120 return NULL;
24121 }
24122
24123
24124 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24125 PyObject *resultobj;
24126 wxPyApp *arg1 = (wxPyApp *) 0 ;
24127 int result;
24128 PyObject * obj0 = 0 ;
24129 char *kwnames[] = {
24130 (char *) "self", NULL
24131 };
24132
24133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24135 if (SWIG_arg_fail(1)) SWIG_fail;
24136 {
24137 PyThreadState* __tstate = wxPyBeginAllowThreads();
24138 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24139
24140 wxPyEndAllowThreads(__tstate);
24141 if (PyErr_Occurred()) SWIG_fail;
24142 }
24143 {
24144 resultobj = SWIG_From_int((int)(result));
24145 }
24146 return resultobj;
24147 fail:
24148 return NULL;
24149 }
24150
24151
24152 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24153 PyObject *resultobj;
24154 wxPyApp *arg1 = (wxPyApp *) 0 ;
24155 int arg2 ;
24156 PyObject * obj0 = 0 ;
24157 PyObject * obj1 = 0 ;
24158 char *kwnames[] = {
24159 (char *) "self",(char *) "mode", NULL
24160 };
24161
24162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24164 if (SWIG_arg_fail(1)) SWIG_fail;
24165 {
24166 arg2 = (int)(SWIG_As_int(obj1));
24167 if (SWIG_arg_fail(2)) SWIG_fail;
24168 }
24169 {
24170 PyThreadState* __tstate = wxPyBeginAllowThreads();
24171 (arg1)->SetAssertMode(arg2);
24172
24173 wxPyEndAllowThreads(__tstate);
24174 if (PyErr_Occurred()) SWIG_fail;
24175 }
24176 Py_INCREF(Py_None); resultobj = Py_None;
24177 return resultobj;
24178 fail:
24179 return NULL;
24180 }
24181
24182
24183 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24184 PyObject *resultobj;
24185 wxPyApp *arg1 = (wxPyApp *) 0 ;
24186 int result;
24187 PyObject * obj0 = 0 ;
24188 char *kwnames[] = {
24189 (char *) "self", NULL
24190 };
24191
24192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24194 if (SWIG_arg_fail(1)) SWIG_fail;
24195 {
24196 PyThreadState* __tstate = wxPyBeginAllowThreads();
24197 result = (int)(arg1)->GetAssertMode();
24198
24199 wxPyEndAllowThreads(__tstate);
24200 if (PyErr_Occurred()) SWIG_fail;
24201 }
24202 {
24203 resultobj = SWIG_From_int((int)(result));
24204 }
24205 return resultobj;
24206 fail:
24207 return NULL;
24208 }
24209
24210
24211 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24212 PyObject *resultobj;
24213 bool result;
24214 char *kwnames[] = {
24215 NULL
24216 };
24217
24218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24219 {
24220 PyThreadState* __tstate = wxPyBeginAllowThreads();
24221 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24222
24223 wxPyEndAllowThreads(__tstate);
24224 if (PyErr_Occurred()) SWIG_fail;
24225 }
24226 {
24227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24228 }
24229 return resultobj;
24230 fail:
24231 return NULL;
24232 }
24233
24234
24235 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24236 PyObject *resultobj;
24237 long result;
24238 char *kwnames[] = {
24239 NULL
24240 };
24241
24242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24243 {
24244 PyThreadState* __tstate = wxPyBeginAllowThreads();
24245 result = (long)wxPyApp::GetMacAboutMenuItemId();
24246
24247 wxPyEndAllowThreads(__tstate);
24248 if (PyErr_Occurred()) SWIG_fail;
24249 }
24250 {
24251 resultobj = SWIG_From_long((long)(result));
24252 }
24253 return resultobj;
24254 fail:
24255 return NULL;
24256 }
24257
24258
24259 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24260 PyObject *resultobj;
24261 long result;
24262 char *kwnames[] = {
24263 NULL
24264 };
24265
24266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24267 {
24268 PyThreadState* __tstate = wxPyBeginAllowThreads();
24269 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24270
24271 wxPyEndAllowThreads(__tstate);
24272 if (PyErr_Occurred()) SWIG_fail;
24273 }
24274 {
24275 resultobj = SWIG_From_long((long)(result));
24276 }
24277 return resultobj;
24278 fail:
24279 return NULL;
24280 }
24281
24282
24283 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24284 PyObject *resultobj;
24285 long result;
24286 char *kwnames[] = {
24287 NULL
24288 };
24289
24290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24291 {
24292 PyThreadState* __tstate = wxPyBeginAllowThreads();
24293 result = (long)wxPyApp::GetMacExitMenuItemId();
24294
24295 wxPyEndAllowThreads(__tstate);
24296 if (PyErr_Occurred()) SWIG_fail;
24297 }
24298 {
24299 resultobj = SWIG_From_long((long)(result));
24300 }
24301 return resultobj;
24302 fail:
24303 return NULL;
24304 }
24305
24306
24307 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24308 PyObject *resultobj;
24309 wxString result;
24310 char *kwnames[] = {
24311 NULL
24312 };
24313
24314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24315 {
24316 PyThreadState* __tstate = wxPyBeginAllowThreads();
24317 result = wxPyApp::GetMacHelpMenuTitleName();
24318
24319 wxPyEndAllowThreads(__tstate);
24320 if (PyErr_Occurred()) SWIG_fail;
24321 }
24322 {
24323 #if wxUSE_UNICODE
24324 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24325 #else
24326 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24327 #endif
24328 }
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj;
24337 bool arg1 ;
24338 PyObject * obj0 = 0 ;
24339 char *kwnames[] = {
24340 (char *) "val", NULL
24341 };
24342
24343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24344 {
24345 arg1 = (bool)(SWIG_As_bool(obj0));
24346 if (SWIG_arg_fail(1)) SWIG_fail;
24347 }
24348 {
24349 PyThreadState* __tstate = wxPyBeginAllowThreads();
24350 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24351
24352 wxPyEndAllowThreads(__tstate);
24353 if (PyErr_Occurred()) SWIG_fail;
24354 }
24355 Py_INCREF(Py_None); resultobj = Py_None;
24356 return resultobj;
24357 fail:
24358 return NULL;
24359 }
24360
24361
24362 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24363 PyObject *resultobj;
24364 long arg1 ;
24365 PyObject * obj0 = 0 ;
24366 char *kwnames[] = {
24367 (char *) "val", NULL
24368 };
24369
24370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24371 {
24372 arg1 = (long)(SWIG_As_long(obj0));
24373 if (SWIG_arg_fail(1)) SWIG_fail;
24374 }
24375 {
24376 PyThreadState* __tstate = wxPyBeginAllowThreads();
24377 wxPyApp::SetMacAboutMenuItemId(arg1);
24378
24379 wxPyEndAllowThreads(__tstate);
24380 if (PyErr_Occurred()) SWIG_fail;
24381 }
24382 Py_INCREF(Py_None); resultobj = Py_None;
24383 return resultobj;
24384 fail:
24385 return NULL;
24386 }
24387
24388
24389 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24390 PyObject *resultobj;
24391 long arg1 ;
24392 PyObject * obj0 = 0 ;
24393 char *kwnames[] = {
24394 (char *) "val", NULL
24395 };
24396
24397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24398 {
24399 arg1 = (long)(SWIG_As_long(obj0));
24400 if (SWIG_arg_fail(1)) SWIG_fail;
24401 }
24402 {
24403 PyThreadState* __tstate = wxPyBeginAllowThreads();
24404 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24405
24406 wxPyEndAllowThreads(__tstate);
24407 if (PyErr_Occurred()) SWIG_fail;
24408 }
24409 Py_INCREF(Py_None); resultobj = Py_None;
24410 return resultobj;
24411 fail:
24412 return NULL;
24413 }
24414
24415
24416 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24417 PyObject *resultobj;
24418 long arg1 ;
24419 PyObject * obj0 = 0 ;
24420 char *kwnames[] = {
24421 (char *) "val", NULL
24422 };
24423
24424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24425 {
24426 arg1 = (long)(SWIG_As_long(obj0));
24427 if (SWIG_arg_fail(1)) SWIG_fail;
24428 }
24429 {
24430 PyThreadState* __tstate = wxPyBeginAllowThreads();
24431 wxPyApp::SetMacExitMenuItemId(arg1);
24432
24433 wxPyEndAllowThreads(__tstate);
24434 if (PyErr_Occurred()) SWIG_fail;
24435 }
24436 Py_INCREF(Py_None); resultobj = Py_None;
24437 return resultobj;
24438 fail:
24439 return NULL;
24440 }
24441
24442
24443 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24444 PyObject *resultobj;
24445 wxString *arg1 = 0 ;
24446 bool temp1 = false ;
24447 PyObject * obj0 = 0 ;
24448 char *kwnames[] = {
24449 (char *) "val", NULL
24450 };
24451
24452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24453 {
24454 arg1 = wxString_in_helper(obj0);
24455 if (arg1 == NULL) SWIG_fail;
24456 temp1 = true;
24457 }
24458 {
24459 PyThreadState* __tstate = wxPyBeginAllowThreads();
24460 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24461
24462 wxPyEndAllowThreads(__tstate);
24463 if (PyErr_Occurred()) SWIG_fail;
24464 }
24465 Py_INCREF(Py_None); resultobj = Py_None;
24466 {
24467 if (temp1)
24468 delete arg1;
24469 }
24470 return resultobj;
24471 fail:
24472 {
24473 if (temp1)
24474 delete arg1;
24475 }
24476 return NULL;
24477 }
24478
24479
24480 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24481 PyObject *resultobj;
24482 wxPyApp *arg1 = (wxPyApp *) 0 ;
24483 PyObject * obj0 = 0 ;
24484 char *kwnames[] = {
24485 (char *) "self", NULL
24486 };
24487
24488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24490 if (SWIG_arg_fail(1)) SWIG_fail;
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 (arg1)->_BootstrapApp();
24494
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 Py_INCREF(Py_None); resultobj = Py_None;
24499 return resultobj;
24500 fail:
24501 return NULL;
24502 }
24503
24504
24505 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24506 PyObject *resultobj;
24507 int result;
24508 char *kwnames[] = {
24509 NULL
24510 };
24511
24512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24513 {
24514 PyThreadState* __tstate = wxPyBeginAllowThreads();
24515 result = (int)PyApp_GetComCtl32Version();
24516
24517 wxPyEndAllowThreads(__tstate);
24518 if (PyErr_Occurred()) SWIG_fail;
24519 }
24520 {
24521 resultobj = SWIG_From_int((int)(result));
24522 }
24523 return resultobj;
24524 fail:
24525 return NULL;
24526 }
24527
24528
24529 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24530 PyObject *obj;
24531 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24532 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24533 Py_INCREF(obj);
24534 return Py_BuildValue((char *)"");
24535 }
24536 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24537 PyObject *resultobj;
24538 char *kwnames[] = {
24539 NULL
24540 };
24541
24542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24543 {
24544 PyThreadState* __tstate = wxPyBeginAllowThreads();
24545 wxExit();
24546
24547 wxPyEndAllowThreads(__tstate);
24548 if (PyErr_Occurred()) SWIG_fail;
24549 }
24550 Py_INCREF(Py_None); resultobj = Py_None;
24551 return resultobj;
24552 fail:
24553 return NULL;
24554 }
24555
24556
24557 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24558 PyObject *resultobj;
24559 bool result;
24560 char *kwnames[] = {
24561 NULL
24562 };
24563
24564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24565 {
24566 PyThreadState* __tstate = wxPyBeginAllowThreads();
24567 result = (bool)wxYield();
24568
24569 wxPyEndAllowThreads(__tstate);
24570 if (PyErr_Occurred()) SWIG_fail;
24571 }
24572 {
24573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24574 }
24575 return resultobj;
24576 fail:
24577 return NULL;
24578 }
24579
24580
24581 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24582 PyObject *resultobj;
24583 bool result;
24584 char *kwnames[] = {
24585 NULL
24586 };
24587
24588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24589 {
24590 PyThreadState* __tstate = wxPyBeginAllowThreads();
24591 result = (bool)wxYieldIfNeeded();
24592
24593 wxPyEndAllowThreads(__tstate);
24594 if (PyErr_Occurred()) SWIG_fail;
24595 }
24596 {
24597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24598 }
24599 return resultobj;
24600 fail:
24601 return NULL;
24602 }
24603
24604
24605 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24606 PyObject *resultobj;
24607 wxWindow *arg1 = (wxWindow *) NULL ;
24608 bool arg2 = (bool) false ;
24609 bool result;
24610 PyObject * obj0 = 0 ;
24611 PyObject * obj1 = 0 ;
24612 char *kwnames[] = {
24613 (char *) "win",(char *) "onlyIfNeeded", NULL
24614 };
24615
24616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24617 if (obj0) {
24618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24619 if (SWIG_arg_fail(1)) SWIG_fail;
24620 }
24621 if (obj1) {
24622 {
24623 arg2 = (bool)(SWIG_As_bool(obj1));
24624 if (SWIG_arg_fail(2)) SWIG_fail;
24625 }
24626 }
24627 {
24628 PyThreadState* __tstate = wxPyBeginAllowThreads();
24629 result = (bool)wxSafeYield(arg1,arg2);
24630
24631 wxPyEndAllowThreads(__tstate);
24632 if (PyErr_Occurred()) SWIG_fail;
24633 }
24634 {
24635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24636 }
24637 return resultobj;
24638 fail:
24639 return NULL;
24640 }
24641
24642
24643 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24644 PyObject *resultobj;
24645 char *kwnames[] = {
24646 NULL
24647 };
24648
24649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24650 {
24651 PyThreadState* __tstate = wxPyBeginAllowThreads();
24652 wxWakeUpIdle();
24653
24654 wxPyEndAllowThreads(__tstate);
24655 if (PyErr_Occurred()) SWIG_fail;
24656 }
24657 Py_INCREF(Py_None); resultobj = Py_None;
24658 return resultobj;
24659 fail:
24660 return NULL;
24661 }
24662
24663
24664 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24665 PyObject *resultobj;
24666 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24667 wxEvent *arg2 = 0 ;
24668 PyObject * obj0 = 0 ;
24669 PyObject * obj1 = 0 ;
24670 char *kwnames[] = {
24671 (char *) "dest",(char *) "event", NULL
24672 };
24673
24674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24676 if (SWIG_arg_fail(1)) SWIG_fail;
24677 {
24678 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24679 if (SWIG_arg_fail(2)) SWIG_fail;
24680 if (arg2 == NULL) {
24681 SWIG_null_ref("wxEvent");
24682 }
24683 if (SWIG_arg_fail(2)) SWIG_fail;
24684 }
24685 {
24686 PyThreadState* __tstate = wxPyBeginAllowThreads();
24687 wxPostEvent(arg1,*arg2);
24688
24689 wxPyEndAllowThreads(__tstate);
24690 if (PyErr_Occurred()) SWIG_fail;
24691 }
24692 Py_INCREF(Py_None); resultobj = Py_None;
24693 return resultobj;
24694 fail:
24695 return NULL;
24696 }
24697
24698
24699 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24700 PyObject *resultobj;
24701 char *kwnames[] = {
24702 NULL
24703 };
24704
24705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24706 {
24707 PyThreadState* __tstate = wxPyBeginAllowThreads();
24708 wxApp_CleanUp();
24709
24710 wxPyEndAllowThreads(__tstate);
24711 if (PyErr_Occurred()) SWIG_fail;
24712 }
24713 Py_INCREF(Py_None); resultobj = Py_None;
24714 return resultobj;
24715 fail:
24716 return NULL;
24717 }
24718
24719
24720 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24721 PyObject *resultobj;
24722 wxPyApp *result;
24723 char *kwnames[] = {
24724 NULL
24725 };
24726
24727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24728 {
24729 PyThreadState* __tstate = wxPyBeginAllowThreads();
24730 result = (wxPyApp *)wxPyGetApp();
24731
24732 wxPyEndAllowThreads(__tstate);
24733 if (PyErr_Occurred()) SWIG_fail;
24734 }
24735 {
24736 resultobj = wxPyMake_wxObject(result, 0);
24737 }
24738 return resultobj;
24739 fail:
24740 return NULL;
24741 }
24742
24743
24744 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24745 PyObject *resultobj;
24746 char *arg1 = (char *) 0 ;
24747 PyObject * obj0 = 0 ;
24748 char *kwnames[] = {
24749 (char *) "encoding", NULL
24750 };
24751
24752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24753 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24754 SWIG_arg_fail(1);SWIG_fail;
24755 }
24756 {
24757 PyThreadState* __tstate = wxPyBeginAllowThreads();
24758 wxSetDefaultPyEncoding((char const *)arg1);
24759
24760 wxPyEndAllowThreads(__tstate);
24761 if (PyErr_Occurred()) SWIG_fail;
24762 }
24763 Py_INCREF(Py_None); resultobj = Py_None;
24764 return resultobj;
24765 fail:
24766 return NULL;
24767 }
24768
24769
24770 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24771 PyObject *resultobj;
24772 char *result;
24773 char *kwnames[] = {
24774 NULL
24775 };
24776
24777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24778 {
24779 PyThreadState* __tstate = wxPyBeginAllowThreads();
24780 result = (char *)wxGetDefaultPyEncoding();
24781
24782 wxPyEndAllowThreads(__tstate);
24783 if (PyErr_Occurred()) SWIG_fail;
24784 }
24785 resultobj = SWIG_FromCharPtr(result);
24786 return resultobj;
24787 fail:
24788 return NULL;
24789 }
24790
24791
24792 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24793 PyObject *resultobj;
24794 wxEventLoop *result;
24795 char *kwnames[] = {
24796 NULL
24797 };
24798
24799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24800 {
24801 PyThreadState* __tstate = wxPyBeginAllowThreads();
24802 result = (wxEventLoop *)new wxEventLoop();
24803
24804 wxPyEndAllowThreads(__tstate);
24805 if (PyErr_Occurred()) SWIG_fail;
24806 }
24807 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24808 return resultobj;
24809 fail:
24810 return NULL;
24811 }
24812
24813
24814 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24815 PyObject *resultobj;
24816 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24817 PyObject * obj0 = 0 ;
24818 char *kwnames[] = {
24819 (char *) "self", NULL
24820 };
24821
24822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24824 if (SWIG_arg_fail(1)) SWIG_fail;
24825 {
24826 PyThreadState* __tstate = wxPyBeginAllowThreads();
24827 delete arg1;
24828
24829 wxPyEndAllowThreads(__tstate);
24830 if (PyErr_Occurred()) SWIG_fail;
24831 }
24832 Py_INCREF(Py_None); resultobj = Py_None;
24833 return resultobj;
24834 fail:
24835 return NULL;
24836 }
24837
24838
24839 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24840 PyObject *resultobj;
24841 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24842 int result;
24843 PyObject * obj0 = 0 ;
24844 char *kwnames[] = {
24845 (char *) "self", NULL
24846 };
24847
24848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24850 if (SWIG_arg_fail(1)) SWIG_fail;
24851 {
24852 PyThreadState* __tstate = wxPyBeginAllowThreads();
24853 result = (int)(arg1)->Run();
24854
24855 wxPyEndAllowThreads(__tstate);
24856 if (PyErr_Occurred()) SWIG_fail;
24857 }
24858 {
24859 resultobj = SWIG_From_int((int)(result));
24860 }
24861 return resultobj;
24862 fail:
24863 return NULL;
24864 }
24865
24866
24867 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24868 PyObject *resultobj;
24869 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24870 int arg2 = (int) 0 ;
24871 PyObject * obj0 = 0 ;
24872 PyObject * obj1 = 0 ;
24873 char *kwnames[] = {
24874 (char *) "self",(char *) "rc", NULL
24875 };
24876
24877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24879 if (SWIG_arg_fail(1)) SWIG_fail;
24880 if (obj1) {
24881 {
24882 arg2 = (int)(SWIG_As_int(obj1));
24883 if (SWIG_arg_fail(2)) SWIG_fail;
24884 }
24885 }
24886 {
24887 PyThreadState* __tstate = wxPyBeginAllowThreads();
24888 (arg1)->Exit(arg2);
24889
24890 wxPyEndAllowThreads(__tstate);
24891 if (PyErr_Occurred()) SWIG_fail;
24892 }
24893 Py_INCREF(Py_None); resultobj = Py_None;
24894 return resultobj;
24895 fail:
24896 return NULL;
24897 }
24898
24899
24900 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24901 PyObject *resultobj;
24902 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24903 bool result;
24904 PyObject * obj0 = 0 ;
24905 char *kwnames[] = {
24906 (char *) "self", NULL
24907 };
24908
24909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24911 if (SWIG_arg_fail(1)) SWIG_fail;
24912 {
24913 PyThreadState* __tstate = wxPyBeginAllowThreads();
24914 result = (bool)((wxEventLoop const *)arg1)->Pending();
24915
24916 wxPyEndAllowThreads(__tstate);
24917 if (PyErr_Occurred()) SWIG_fail;
24918 }
24919 {
24920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24921 }
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj;
24930 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24931 bool result;
24932 PyObject * obj0 = 0 ;
24933 char *kwnames[] = {
24934 (char *) "self", NULL
24935 };
24936
24937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24939 if (SWIG_arg_fail(1)) SWIG_fail;
24940 {
24941 PyThreadState* __tstate = wxPyBeginAllowThreads();
24942 result = (bool)(arg1)->Dispatch();
24943
24944 wxPyEndAllowThreads(__tstate);
24945 if (PyErr_Occurred()) SWIG_fail;
24946 }
24947 {
24948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24949 }
24950 return resultobj;
24951 fail:
24952 return NULL;
24953 }
24954
24955
24956 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24957 PyObject *resultobj;
24958 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24959 bool result;
24960 PyObject * obj0 = 0 ;
24961 char *kwnames[] = {
24962 (char *) "self", NULL
24963 };
24964
24965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24967 if (SWIG_arg_fail(1)) SWIG_fail;
24968 {
24969 PyThreadState* __tstate = wxPyBeginAllowThreads();
24970 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24971
24972 wxPyEndAllowThreads(__tstate);
24973 if (PyErr_Occurred()) SWIG_fail;
24974 }
24975 {
24976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24977 }
24978 return resultobj;
24979 fail:
24980 return NULL;
24981 }
24982
24983
24984 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24985 PyObject *resultobj;
24986 wxEventLoop *result;
24987 char *kwnames[] = {
24988 NULL
24989 };
24990
24991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24992 {
24993 PyThreadState* __tstate = wxPyBeginAllowThreads();
24994 result = (wxEventLoop *)wxEventLoop::GetActive();
24995
24996 wxPyEndAllowThreads(__tstate);
24997 if (PyErr_Occurred()) SWIG_fail;
24998 }
24999 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
25000 return resultobj;
25001 fail:
25002 return NULL;
25003 }
25004
25005
25006 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25007 PyObject *resultobj;
25008 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25009 PyObject * obj0 = 0 ;
25010 char *kwnames[] = {
25011 (char *) "loop", NULL
25012 };
25013
25014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
25015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25016 if (SWIG_arg_fail(1)) SWIG_fail;
25017 {
25018 PyThreadState* __tstate = wxPyBeginAllowThreads();
25019 wxEventLoop::SetActive(arg1);
25020
25021 wxPyEndAllowThreads(__tstate);
25022 if (PyErr_Occurred()) SWIG_fail;
25023 }
25024 Py_INCREF(Py_None); resultobj = Py_None;
25025 return resultobj;
25026 fail:
25027 return NULL;
25028 }
25029
25030
25031 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25032 PyObject *obj;
25033 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25034 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25035 Py_INCREF(obj);
25036 return Py_BuildValue((char *)"");
25037 }
25038 static PyObject *_wrap_new_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25039 PyObject *resultobj;
25040 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25041 wxEventLoopActivator *result;
25042 PyObject * obj0 = 0 ;
25043 char *kwnames[] = {
25044 (char *) "evtLoop", NULL
25045 };
25046
25047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) goto fail;
25048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25049 if (SWIG_arg_fail(1)) SWIG_fail;
25050 {
25051 PyThreadState* __tstate = wxPyBeginAllowThreads();
25052 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
25053
25054 wxPyEndAllowThreads(__tstate);
25055 if (PyErr_Occurred()) SWIG_fail;
25056 }
25057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoopActivator, 1);
25058 return resultobj;
25059 fail:
25060 return NULL;
25061 }
25062
25063
25064 static PyObject *_wrap_delete_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25065 PyObject *resultobj;
25066 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
25067 PyObject * obj0 = 0 ;
25068 char *kwnames[] = {
25069 (char *) "self", NULL
25070 };
25071
25072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoopActivator",kwnames,&obj0)) goto fail;
25073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_EXCEPTION | 0);
25074 if (SWIG_arg_fail(1)) SWIG_fail;
25075 {
25076 PyThreadState* __tstate = wxPyBeginAllowThreads();
25077 delete arg1;
25078
25079 wxPyEndAllowThreads(__tstate);
25080 if (PyErr_Occurred()) SWIG_fail;
25081 }
25082 Py_INCREF(Py_None); resultobj = Py_None;
25083 return resultobj;
25084 fail:
25085 return NULL;
25086 }
25087
25088
25089 static PyObject * EventLoopActivator_swigregister(PyObject *, PyObject *args) {
25090 PyObject *obj;
25091 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25092 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoopActivator, obj);
25093 Py_INCREF(obj);
25094 return Py_BuildValue((char *)"");
25095 }
25096 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25097 PyObject *resultobj;
25098 int arg1 = (int) 0 ;
25099 int arg2 = (int) 0 ;
25100 int arg3 = (int) 0 ;
25101 wxAcceleratorEntry *result;
25102 PyObject * obj0 = 0 ;
25103 PyObject * obj1 = 0 ;
25104 PyObject * obj2 = 0 ;
25105 char *kwnames[] = {
25106 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25107 };
25108
25109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25110 if (obj0) {
25111 {
25112 arg1 = (int)(SWIG_As_int(obj0));
25113 if (SWIG_arg_fail(1)) SWIG_fail;
25114 }
25115 }
25116 if (obj1) {
25117 {
25118 arg2 = (int)(SWIG_As_int(obj1));
25119 if (SWIG_arg_fail(2)) SWIG_fail;
25120 }
25121 }
25122 if (obj2) {
25123 {
25124 arg3 = (int)(SWIG_As_int(obj2));
25125 if (SWIG_arg_fail(3)) SWIG_fail;
25126 }
25127 }
25128 {
25129 PyThreadState* __tstate = wxPyBeginAllowThreads();
25130 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25131
25132 wxPyEndAllowThreads(__tstate);
25133 if (PyErr_Occurred()) SWIG_fail;
25134 }
25135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25136 return resultobj;
25137 fail:
25138 return NULL;
25139 }
25140
25141
25142 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25143 PyObject *resultobj;
25144 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25145 PyObject * obj0 = 0 ;
25146 char *kwnames[] = {
25147 (char *) "self", NULL
25148 };
25149
25150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25152 if (SWIG_arg_fail(1)) SWIG_fail;
25153 {
25154 PyThreadState* __tstate = wxPyBeginAllowThreads();
25155 delete arg1;
25156
25157 wxPyEndAllowThreads(__tstate);
25158 if (PyErr_Occurred()) SWIG_fail;
25159 }
25160 Py_INCREF(Py_None); resultobj = Py_None;
25161 return resultobj;
25162 fail:
25163 return NULL;
25164 }
25165
25166
25167 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25168 PyObject *resultobj;
25169 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25170 int arg2 ;
25171 int arg3 ;
25172 int arg4 ;
25173 PyObject * obj0 = 0 ;
25174 PyObject * obj1 = 0 ;
25175 PyObject * obj2 = 0 ;
25176 PyObject * obj3 = 0 ;
25177 char *kwnames[] = {
25178 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25179 };
25180
25181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25183 if (SWIG_arg_fail(1)) SWIG_fail;
25184 {
25185 arg2 = (int)(SWIG_As_int(obj1));
25186 if (SWIG_arg_fail(2)) SWIG_fail;
25187 }
25188 {
25189 arg3 = (int)(SWIG_As_int(obj2));
25190 if (SWIG_arg_fail(3)) SWIG_fail;
25191 }
25192 {
25193 arg4 = (int)(SWIG_As_int(obj3));
25194 if (SWIG_arg_fail(4)) SWIG_fail;
25195 }
25196 {
25197 PyThreadState* __tstate = wxPyBeginAllowThreads();
25198 (arg1)->Set(arg2,arg3,arg4);
25199
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 Py_INCREF(Py_None); resultobj = Py_None;
25204 return resultobj;
25205 fail:
25206 return NULL;
25207 }
25208
25209
25210 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25211 PyObject *resultobj;
25212 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25213 int result;
25214 PyObject * obj0 = 0 ;
25215 char *kwnames[] = {
25216 (char *) "self", NULL
25217 };
25218
25219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25221 if (SWIG_arg_fail(1)) SWIG_fail;
25222 {
25223 PyThreadState* __tstate = wxPyBeginAllowThreads();
25224 result = (int)(arg1)->GetFlags();
25225
25226 wxPyEndAllowThreads(__tstate);
25227 if (PyErr_Occurred()) SWIG_fail;
25228 }
25229 {
25230 resultobj = SWIG_From_int((int)(result));
25231 }
25232 return resultobj;
25233 fail:
25234 return NULL;
25235 }
25236
25237
25238 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25239 PyObject *resultobj;
25240 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25241 int result;
25242 PyObject * obj0 = 0 ;
25243 char *kwnames[] = {
25244 (char *) "self", NULL
25245 };
25246
25247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25249 if (SWIG_arg_fail(1)) SWIG_fail;
25250 {
25251 PyThreadState* __tstate = wxPyBeginAllowThreads();
25252 result = (int)(arg1)->GetKeyCode();
25253
25254 wxPyEndAllowThreads(__tstate);
25255 if (PyErr_Occurred()) SWIG_fail;
25256 }
25257 {
25258 resultobj = SWIG_From_int((int)(result));
25259 }
25260 return resultobj;
25261 fail:
25262 return NULL;
25263 }
25264
25265
25266 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25267 PyObject *resultobj;
25268 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25269 int result;
25270 PyObject * obj0 = 0 ;
25271 char *kwnames[] = {
25272 (char *) "self", NULL
25273 };
25274
25275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25277 if (SWIG_arg_fail(1)) SWIG_fail;
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 result = (int)(arg1)->GetCommand();
25281
25282 wxPyEndAllowThreads(__tstate);
25283 if (PyErr_Occurred()) SWIG_fail;
25284 }
25285 {
25286 resultobj = SWIG_From_int((int)(result));
25287 }
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25295 PyObject *obj;
25296 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25297 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25298 Py_INCREF(obj);
25299 return Py_BuildValue((char *)"");
25300 }
25301 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25302 PyObject *resultobj;
25303 int arg1 ;
25304 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25305 wxAcceleratorTable *result;
25306 PyObject * obj0 = 0 ;
25307 char *kwnames[] = {
25308 (char *) "n", NULL
25309 };
25310
25311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25312 {
25313 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25314 if (arg2) arg1 = PyList_Size(obj0);
25315 else arg1 = 0;
25316 }
25317 {
25318 PyThreadState* __tstate = wxPyBeginAllowThreads();
25319 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25320
25321 wxPyEndAllowThreads(__tstate);
25322 if (PyErr_Occurred()) SWIG_fail;
25323 }
25324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25325 {
25326 delete [] arg2;
25327 }
25328 return resultobj;
25329 fail:
25330 {
25331 delete [] arg2;
25332 }
25333 return NULL;
25334 }
25335
25336
25337 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25338 PyObject *resultobj;
25339 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25340 PyObject * obj0 = 0 ;
25341 char *kwnames[] = {
25342 (char *) "self", NULL
25343 };
25344
25345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25347 if (SWIG_arg_fail(1)) SWIG_fail;
25348 {
25349 PyThreadState* __tstate = wxPyBeginAllowThreads();
25350 delete arg1;
25351
25352 wxPyEndAllowThreads(__tstate);
25353 if (PyErr_Occurred()) SWIG_fail;
25354 }
25355 Py_INCREF(Py_None); resultobj = Py_None;
25356 return resultobj;
25357 fail:
25358 return NULL;
25359 }
25360
25361
25362 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25363 PyObject *resultobj;
25364 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25365 bool result;
25366 PyObject * obj0 = 0 ;
25367 char *kwnames[] = {
25368 (char *) "self", NULL
25369 };
25370
25371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25373 if (SWIG_arg_fail(1)) SWIG_fail;
25374 {
25375 PyThreadState* __tstate = wxPyBeginAllowThreads();
25376 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25377
25378 wxPyEndAllowThreads(__tstate);
25379 if (PyErr_Occurred()) SWIG_fail;
25380 }
25381 {
25382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25383 }
25384 return resultobj;
25385 fail:
25386 return NULL;
25387 }
25388
25389
25390 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25391 PyObject *obj;
25392 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25393 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25394 Py_INCREF(obj);
25395 return Py_BuildValue((char *)"");
25396 }
25397 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25398 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25399 return 1;
25400 }
25401
25402
25403 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25404 PyObject *pyobj;
25405
25406 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25407 return pyobj;
25408 }
25409
25410
25411 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25412 PyObject *resultobj;
25413 wxString *arg1 = 0 ;
25414 wxAcceleratorEntry *result;
25415 bool temp1 = false ;
25416 PyObject * obj0 = 0 ;
25417 char *kwnames[] = {
25418 (char *) "label", NULL
25419 };
25420
25421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25422 {
25423 arg1 = wxString_in_helper(obj0);
25424 if (arg1 == NULL) SWIG_fail;
25425 temp1 = true;
25426 }
25427 {
25428 PyThreadState* __tstate = wxPyBeginAllowThreads();
25429 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25430
25431 wxPyEndAllowThreads(__tstate);
25432 if (PyErr_Occurred()) SWIG_fail;
25433 }
25434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25435 {
25436 if (temp1)
25437 delete arg1;
25438 }
25439 return resultobj;
25440 fail:
25441 {
25442 if (temp1)
25443 delete arg1;
25444 }
25445 return NULL;
25446 }
25447
25448
25449 static int _wrap_PanelNameStr_set(PyObject *) {
25450 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25451 return 1;
25452 }
25453
25454
25455 static PyObject *_wrap_PanelNameStr_get(void) {
25456 PyObject *pyobj;
25457
25458 {
25459 #if wxUSE_UNICODE
25460 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25461 #else
25462 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25463 #endif
25464 }
25465 return pyobj;
25466 }
25467
25468
25469 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25470 PyObject *resultobj;
25471 wxVisualAttributes *result;
25472 char *kwnames[] = {
25473 NULL
25474 };
25475
25476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25477 {
25478 PyThreadState* __tstate = wxPyBeginAllowThreads();
25479 result = (wxVisualAttributes *)new_wxVisualAttributes();
25480
25481 wxPyEndAllowThreads(__tstate);
25482 if (PyErr_Occurred()) SWIG_fail;
25483 }
25484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25485 return resultobj;
25486 fail:
25487 return NULL;
25488 }
25489
25490
25491 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25492 PyObject *resultobj;
25493 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25494 PyObject * obj0 = 0 ;
25495 char *kwnames[] = {
25496 (char *) "self", NULL
25497 };
25498
25499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25501 if (SWIG_arg_fail(1)) SWIG_fail;
25502 {
25503 PyThreadState* __tstate = wxPyBeginAllowThreads();
25504 delete_wxVisualAttributes(arg1);
25505
25506 wxPyEndAllowThreads(__tstate);
25507 if (PyErr_Occurred()) SWIG_fail;
25508 }
25509 Py_INCREF(Py_None); resultobj = Py_None;
25510 return resultobj;
25511 fail:
25512 return NULL;
25513 }
25514
25515
25516 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25517 PyObject *resultobj;
25518 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25519 wxFont *arg2 = (wxFont *) 0 ;
25520 PyObject * obj0 = 0 ;
25521 PyObject * obj1 = 0 ;
25522 char *kwnames[] = {
25523 (char *) "self",(char *) "font", NULL
25524 };
25525
25526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25528 if (SWIG_arg_fail(1)) SWIG_fail;
25529 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25530 if (SWIG_arg_fail(2)) SWIG_fail;
25531 if (arg1) (arg1)->font = *arg2;
25532
25533 Py_INCREF(Py_None); resultobj = Py_None;
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25541 PyObject *resultobj;
25542 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25543 wxFont *result;
25544 PyObject * obj0 = 0 ;
25545 char *kwnames[] = {
25546 (char *) "self", NULL
25547 };
25548
25549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25551 if (SWIG_arg_fail(1)) SWIG_fail;
25552 result = (wxFont *)& ((arg1)->font);
25553
25554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25562 PyObject *resultobj;
25563 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25564 wxColour *arg2 = (wxColour *) 0 ;
25565 PyObject * obj0 = 0 ;
25566 PyObject * obj1 = 0 ;
25567 char *kwnames[] = {
25568 (char *) "self",(char *) "colFg", NULL
25569 };
25570
25571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25573 if (SWIG_arg_fail(1)) SWIG_fail;
25574 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25575 if (SWIG_arg_fail(2)) SWIG_fail;
25576 if (arg1) (arg1)->colFg = *arg2;
25577
25578 Py_INCREF(Py_None); resultobj = Py_None;
25579 return resultobj;
25580 fail:
25581 return NULL;
25582 }
25583
25584
25585 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25586 PyObject *resultobj;
25587 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25588 wxColour *result;
25589 PyObject * obj0 = 0 ;
25590 char *kwnames[] = {
25591 (char *) "self", NULL
25592 };
25593
25594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25596 if (SWIG_arg_fail(1)) SWIG_fail;
25597 result = (wxColour *)& ((arg1)->colFg);
25598
25599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25600 return resultobj;
25601 fail:
25602 return NULL;
25603 }
25604
25605
25606 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25607 PyObject *resultobj;
25608 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25609 wxColour *arg2 = (wxColour *) 0 ;
25610 PyObject * obj0 = 0 ;
25611 PyObject * obj1 = 0 ;
25612 char *kwnames[] = {
25613 (char *) "self",(char *) "colBg", NULL
25614 };
25615
25616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25618 if (SWIG_arg_fail(1)) SWIG_fail;
25619 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25620 if (SWIG_arg_fail(2)) SWIG_fail;
25621 if (arg1) (arg1)->colBg = *arg2;
25622
25623 Py_INCREF(Py_None); resultobj = Py_None;
25624 return resultobj;
25625 fail:
25626 return NULL;
25627 }
25628
25629
25630 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25631 PyObject *resultobj;
25632 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25633 wxColour *result;
25634 PyObject * obj0 = 0 ;
25635 char *kwnames[] = {
25636 (char *) "self", NULL
25637 };
25638
25639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25641 if (SWIG_arg_fail(1)) SWIG_fail;
25642 result = (wxColour *)& ((arg1)->colBg);
25643
25644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25645 return resultobj;
25646 fail:
25647 return NULL;
25648 }
25649
25650
25651 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25652 PyObject *obj;
25653 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25654 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25655 Py_INCREF(obj);
25656 return Py_BuildValue((char *)"");
25657 }
25658 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25659 PyObject *resultobj;
25660 wxWindow *arg1 = (wxWindow *) 0 ;
25661 int arg2 = (int) (int)-1 ;
25662 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25663 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25664 wxSize const &arg4_defvalue = wxDefaultSize ;
25665 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25666 long arg5 = (long) 0 ;
25667 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25668 wxString *arg6 = (wxString *) &arg6_defvalue ;
25669 wxWindow *result;
25670 wxPoint temp3 ;
25671 wxSize temp4 ;
25672 bool temp6 = false ;
25673 PyObject * obj0 = 0 ;
25674 PyObject * obj1 = 0 ;
25675 PyObject * obj2 = 0 ;
25676 PyObject * obj3 = 0 ;
25677 PyObject * obj4 = 0 ;
25678 PyObject * obj5 = 0 ;
25679 char *kwnames[] = {
25680 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25681 };
25682
25683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25685 if (SWIG_arg_fail(1)) SWIG_fail;
25686 if (obj1) {
25687 {
25688 arg2 = (int const)(SWIG_As_int(obj1));
25689 if (SWIG_arg_fail(2)) SWIG_fail;
25690 }
25691 }
25692 if (obj2) {
25693 {
25694 arg3 = &temp3;
25695 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25696 }
25697 }
25698 if (obj3) {
25699 {
25700 arg4 = &temp4;
25701 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25702 }
25703 }
25704 if (obj4) {
25705 {
25706 arg5 = (long)(SWIG_As_long(obj4));
25707 if (SWIG_arg_fail(5)) SWIG_fail;
25708 }
25709 }
25710 if (obj5) {
25711 {
25712 arg6 = wxString_in_helper(obj5);
25713 if (arg6 == NULL) SWIG_fail;
25714 temp6 = true;
25715 }
25716 }
25717 {
25718 if (!wxPyCheckForApp()) SWIG_fail;
25719 PyThreadState* __tstate = wxPyBeginAllowThreads();
25720 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25721
25722 wxPyEndAllowThreads(__tstate);
25723 if (PyErr_Occurred()) SWIG_fail;
25724 }
25725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25726 {
25727 if (temp6)
25728 delete arg6;
25729 }
25730 return resultobj;
25731 fail:
25732 {
25733 if (temp6)
25734 delete arg6;
25735 }
25736 return NULL;
25737 }
25738
25739
25740 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25741 PyObject *resultobj;
25742 wxWindow *result;
25743 char *kwnames[] = {
25744 NULL
25745 };
25746
25747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25748 {
25749 if (!wxPyCheckForApp()) SWIG_fail;
25750 PyThreadState* __tstate = wxPyBeginAllowThreads();
25751 result = (wxWindow *)new wxWindow();
25752
25753 wxPyEndAllowThreads(__tstate);
25754 if (PyErr_Occurred()) SWIG_fail;
25755 }
25756 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25757 return resultobj;
25758 fail:
25759 return NULL;
25760 }
25761
25762
25763 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25764 PyObject *resultobj;
25765 wxWindow *arg1 = (wxWindow *) 0 ;
25766 wxWindow *arg2 = (wxWindow *) 0 ;
25767 int arg3 = (int) (int)-1 ;
25768 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25769 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25770 wxSize const &arg5_defvalue = wxDefaultSize ;
25771 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25772 long arg6 = (long) 0 ;
25773 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25774 wxString *arg7 = (wxString *) &arg7_defvalue ;
25775 bool result;
25776 wxPoint temp4 ;
25777 wxSize temp5 ;
25778 bool temp7 = false ;
25779 PyObject * obj0 = 0 ;
25780 PyObject * obj1 = 0 ;
25781 PyObject * obj2 = 0 ;
25782 PyObject * obj3 = 0 ;
25783 PyObject * obj4 = 0 ;
25784 PyObject * obj5 = 0 ;
25785 PyObject * obj6 = 0 ;
25786 char *kwnames[] = {
25787 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25788 };
25789
25790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25792 if (SWIG_arg_fail(1)) SWIG_fail;
25793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25794 if (SWIG_arg_fail(2)) SWIG_fail;
25795 if (obj2) {
25796 {
25797 arg3 = (int const)(SWIG_As_int(obj2));
25798 if (SWIG_arg_fail(3)) SWIG_fail;
25799 }
25800 }
25801 if (obj3) {
25802 {
25803 arg4 = &temp4;
25804 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25805 }
25806 }
25807 if (obj4) {
25808 {
25809 arg5 = &temp5;
25810 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25811 }
25812 }
25813 if (obj5) {
25814 {
25815 arg6 = (long)(SWIG_As_long(obj5));
25816 if (SWIG_arg_fail(6)) SWIG_fail;
25817 }
25818 }
25819 if (obj6) {
25820 {
25821 arg7 = wxString_in_helper(obj6);
25822 if (arg7 == NULL) SWIG_fail;
25823 temp7 = true;
25824 }
25825 }
25826 {
25827 PyThreadState* __tstate = wxPyBeginAllowThreads();
25828 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25829
25830 wxPyEndAllowThreads(__tstate);
25831 if (PyErr_Occurred()) SWIG_fail;
25832 }
25833 {
25834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25835 }
25836 {
25837 if (temp7)
25838 delete arg7;
25839 }
25840 return resultobj;
25841 fail:
25842 {
25843 if (temp7)
25844 delete arg7;
25845 }
25846 return NULL;
25847 }
25848
25849
25850 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25851 PyObject *resultobj;
25852 wxWindow *arg1 = (wxWindow *) 0 ;
25853 bool arg2 = (bool) false ;
25854 bool result;
25855 PyObject * obj0 = 0 ;
25856 PyObject * obj1 = 0 ;
25857 char *kwnames[] = {
25858 (char *) "self",(char *) "force", NULL
25859 };
25860
25861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25863 if (SWIG_arg_fail(1)) SWIG_fail;
25864 if (obj1) {
25865 {
25866 arg2 = (bool)(SWIG_As_bool(obj1));
25867 if (SWIG_arg_fail(2)) SWIG_fail;
25868 }
25869 }
25870 {
25871 PyThreadState* __tstate = wxPyBeginAllowThreads();
25872 result = (bool)(arg1)->Close(arg2);
25873
25874 wxPyEndAllowThreads(__tstate);
25875 if (PyErr_Occurred()) SWIG_fail;
25876 }
25877 {
25878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25879 }
25880 return resultobj;
25881 fail:
25882 return NULL;
25883 }
25884
25885
25886 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25887 PyObject *resultobj;
25888 wxWindow *arg1 = (wxWindow *) 0 ;
25889 bool result;
25890 PyObject * obj0 = 0 ;
25891 char *kwnames[] = {
25892 (char *) "self", NULL
25893 };
25894
25895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25897 if (SWIG_arg_fail(1)) SWIG_fail;
25898 {
25899 PyThreadState* __tstate = wxPyBeginAllowThreads();
25900 result = (bool)(arg1)->Destroy();
25901
25902 wxPyEndAllowThreads(__tstate);
25903 if (PyErr_Occurred()) SWIG_fail;
25904 }
25905 {
25906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25907 }
25908 return resultobj;
25909 fail:
25910 return NULL;
25911 }
25912
25913
25914 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25915 PyObject *resultobj;
25916 wxWindow *arg1 = (wxWindow *) 0 ;
25917 bool result;
25918 PyObject * obj0 = 0 ;
25919 char *kwnames[] = {
25920 (char *) "self", NULL
25921 };
25922
25923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25925 if (SWIG_arg_fail(1)) SWIG_fail;
25926 {
25927 PyThreadState* __tstate = wxPyBeginAllowThreads();
25928 result = (bool)(arg1)->DestroyChildren();
25929
25930 wxPyEndAllowThreads(__tstate);
25931 if (PyErr_Occurred()) SWIG_fail;
25932 }
25933 {
25934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25935 }
25936 return resultobj;
25937 fail:
25938 return NULL;
25939 }
25940
25941
25942 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25943 PyObject *resultobj;
25944 wxWindow *arg1 = (wxWindow *) 0 ;
25945 bool result;
25946 PyObject * obj0 = 0 ;
25947 char *kwnames[] = {
25948 (char *) "self", NULL
25949 };
25950
25951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25953 if (SWIG_arg_fail(1)) SWIG_fail;
25954 {
25955 PyThreadState* __tstate = wxPyBeginAllowThreads();
25956 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25957
25958 wxPyEndAllowThreads(__tstate);
25959 if (PyErr_Occurred()) SWIG_fail;
25960 }
25961 {
25962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25963 }
25964 return resultobj;
25965 fail:
25966 return NULL;
25967 }
25968
25969
25970 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25971 PyObject *resultobj;
25972 wxWindow *arg1 = (wxWindow *) 0 ;
25973 wxString *arg2 = 0 ;
25974 bool temp2 = false ;
25975 PyObject * obj0 = 0 ;
25976 PyObject * obj1 = 0 ;
25977 char *kwnames[] = {
25978 (char *) "self",(char *) "label", NULL
25979 };
25980
25981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25983 if (SWIG_arg_fail(1)) SWIG_fail;
25984 {
25985 arg2 = wxString_in_helper(obj1);
25986 if (arg2 == NULL) SWIG_fail;
25987 temp2 = true;
25988 }
25989 {
25990 PyThreadState* __tstate = wxPyBeginAllowThreads();
25991 (arg1)->SetLabel((wxString const &)*arg2);
25992
25993 wxPyEndAllowThreads(__tstate);
25994 if (PyErr_Occurred()) SWIG_fail;
25995 }
25996 Py_INCREF(Py_None); resultobj = Py_None;
25997 {
25998 if (temp2)
25999 delete arg2;
26000 }
26001 return resultobj;
26002 fail:
26003 {
26004 if (temp2)
26005 delete arg2;
26006 }
26007 return NULL;
26008 }
26009
26010
26011 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26012 PyObject *resultobj;
26013 wxWindow *arg1 = (wxWindow *) 0 ;
26014 wxString result;
26015 PyObject * obj0 = 0 ;
26016 char *kwnames[] = {
26017 (char *) "self", NULL
26018 };
26019
26020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
26021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26022 if (SWIG_arg_fail(1)) SWIG_fail;
26023 {
26024 PyThreadState* __tstate = wxPyBeginAllowThreads();
26025 result = ((wxWindow const *)arg1)->GetLabel();
26026
26027 wxPyEndAllowThreads(__tstate);
26028 if (PyErr_Occurred()) SWIG_fail;
26029 }
26030 {
26031 #if wxUSE_UNICODE
26032 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26033 #else
26034 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26035 #endif
26036 }
26037 return resultobj;
26038 fail:
26039 return NULL;
26040 }
26041
26042
26043 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
26044 PyObject *resultobj;
26045 wxWindow *arg1 = (wxWindow *) 0 ;
26046 wxString *arg2 = 0 ;
26047 bool temp2 = false ;
26048 PyObject * obj0 = 0 ;
26049 PyObject * obj1 = 0 ;
26050 char *kwnames[] = {
26051 (char *) "self",(char *) "name", NULL
26052 };
26053
26054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
26055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26056 if (SWIG_arg_fail(1)) SWIG_fail;
26057 {
26058 arg2 = wxString_in_helper(obj1);
26059 if (arg2 == NULL) SWIG_fail;
26060 temp2 = true;
26061 }
26062 {
26063 PyThreadState* __tstate = wxPyBeginAllowThreads();
26064 (arg1)->SetName((wxString const &)*arg2);
26065
26066 wxPyEndAllowThreads(__tstate);
26067 if (PyErr_Occurred()) SWIG_fail;
26068 }
26069 Py_INCREF(Py_None); resultobj = Py_None;
26070 {
26071 if (temp2)
26072 delete arg2;
26073 }
26074 return resultobj;
26075 fail:
26076 {
26077 if (temp2)
26078 delete arg2;
26079 }
26080 return NULL;
26081 }
26082
26083
26084 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26085 PyObject *resultobj;
26086 wxWindow *arg1 = (wxWindow *) 0 ;
26087 wxString result;
26088 PyObject * obj0 = 0 ;
26089 char *kwnames[] = {
26090 (char *) "self", NULL
26091 };
26092
26093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26095 if (SWIG_arg_fail(1)) SWIG_fail;
26096 {
26097 PyThreadState* __tstate = wxPyBeginAllowThreads();
26098 result = ((wxWindow const *)arg1)->GetName();
26099
26100 wxPyEndAllowThreads(__tstate);
26101 if (PyErr_Occurred()) SWIG_fail;
26102 }
26103 {
26104 #if wxUSE_UNICODE
26105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26106 #else
26107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26108 #endif
26109 }
26110 return resultobj;
26111 fail:
26112 return NULL;
26113 }
26114
26115
26116 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26117 PyObject *resultobj;
26118 wxWindow *arg1 = (wxWindow *) 0 ;
26119 wxWindowVariant arg2 ;
26120 PyObject * obj0 = 0 ;
26121 PyObject * obj1 = 0 ;
26122 char *kwnames[] = {
26123 (char *) "self",(char *) "variant", NULL
26124 };
26125
26126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26128 if (SWIG_arg_fail(1)) SWIG_fail;
26129 {
26130 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
26131 if (SWIG_arg_fail(2)) SWIG_fail;
26132 }
26133 {
26134 PyThreadState* __tstate = wxPyBeginAllowThreads();
26135 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
26136
26137 wxPyEndAllowThreads(__tstate);
26138 if (PyErr_Occurred()) SWIG_fail;
26139 }
26140 Py_INCREF(Py_None); resultobj = Py_None;
26141 return resultobj;
26142 fail:
26143 return NULL;
26144 }
26145
26146
26147 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26148 PyObject *resultobj;
26149 wxWindow *arg1 = (wxWindow *) 0 ;
26150 wxWindowVariant result;
26151 PyObject * obj0 = 0 ;
26152 char *kwnames[] = {
26153 (char *) "self", NULL
26154 };
26155
26156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26158 if (SWIG_arg_fail(1)) SWIG_fail;
26159 {
26160 PyThreadState* __tstate = wxPyBeginAllowThreads();
26161 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26162
26163 wxPyEndAllowThreads(__tstate);
26164 if (PyErr_Occurred()) SWIG_fail;
26165 }
26166 resultobj = SWIG_From_int((result));
26167 return resultobj;
26168 fail:
26169 return NULL;
26170 }
26171
26172
26173 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26174 PyObject *resultobj;
26175 wxWindow *arg1 = (wxWindow *) 0 ;
26176 int arg2 ;
26177 PyObject * obj0 = 0 ;
26178 PyObject * obj1 = 0 ;
26179 char *kwnames[] = {
26180 (char *) "self",(char *) "winid", NULL
26181 };
26182
26183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26185 if (SWIG_arg_fail(1)) SWIG_fail;
26186 {
26187 arg2 = (int)(SWIG_As_int(obj1));
26188 if (SWIG_arg_fail(2)) SWIG_fail;
26189 }
26190 {
26191 PyThreadState* __tstate = wxPyBeginAllowThreads();
26192 (arg1)->SetId(arg2);
26193
26194 wxPyEndAllowThreads(__tstate);
26195 if (PyErr_Occurred()) SWIG_fail;
26196 }
26197 Py_INCREF(Py_None); resultobj = Py_None;
26198 return resultobj;
26199 fail:
26200 return NULL;
26201 }
26202
26203
26204 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26205 PyObject *resultobj;
26206 wxWindow *arg1 = (wxWindow *) 0 ;
26207 int result;
26208 PyObject * obj0 = 0 ;
26209 char *kwnames[] = {
26210 (char *) "self", NULL
26211 };
26212
26213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26215 if (SWIG_arg_fail(1)) SWIG_fail;
26216 {
26217 PyThreadState* __tstate = wxPyBeginAllowThreads();
26218 result = (int)((wxWindow const *)arg1)->GetId();
26219
26220 wxPyEndAllowThreads(__tstate);
26221 if (PyErr_Occurred()) SWIG_fail;
26222 }
26223 {
26224 resultobj = SWIG_From_int((int)(result));
26225 }
26226 return resultobj;
26227 fail:
26228 return NULL;
26229 }
26230
26231
26232 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26233 PyObject *resultobj;
26234 int result;
26235 char *kwnames[] = {
26236 NULL
26237 };
26238
26239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26240 {
26241 PyThreadState* __tstate = wxPyBeginAllowThreads();
26242 result = (int)wxWindow::NewControlId();
26243
26244 wxPyEndAllowThreads(__tstate);
26245 if (PyErr_Occurred()) SWIG_fail;
26246 }
26247 {
26248 resultobj = SWIG_From_int((int)(result));
26249 }
26250 return resultobj;
26251 fail:
26252 return NULL;
26253 }
26254
26255
26256 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26257 PyObject *resultobj;
26258 int arg1 ;
26259 int result;
26260 PyObject * obj0 = 0 ;
26261 char *kwnames[] = {
26262 (char *) "winid", NULL
26263 };
26264
26265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26266 {
26267 arg1 = (int)(SWIG_As_int(obj0));
26268 if (SWIG_arg_fail(1)) SWIG_fail;
26269 }
26270 {
26271 PyThreadState* __tstate = wxPyBeginAllowThreads();
26272 result = (int)wxWindow::NextControlId(arg1);
26273
26274 wxPyEndAllowThreads(__tstate);
26275 if (PyErr_Occurred()) SWIG_fail;
26276 }
26277 {
26278 resultobj = SWIG_From_int((int)(result));
26279 }
26280 return resultobj;
26281 fail:
26282 return NULL;
26283 }
26284
26285
26286 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26287 PyObject *resultobj;
26288 int arg1 ;
26289 int result;
26290 PyObject * obj0 = 0 ;
26291 char *kwnames[] = {
26292 (char *) "winid", NULL
26293 };
26294
26295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26296 {
26297 arg1 = (int)(SWIG_As_int(obj0));
26298 if (SWIG_arg_fail(1)) SWIG_fail;
26299 }
26300 {
26301 PyThreadState* __tstate = wxPyBeginAllowThreads();
26302 result = (int)wxWindow::PrevControlId(arg1);
26303
26304 wxPyEndAllowThreads(__tstate);
26305 if (PyErr_Occurred()) SWIG_fail;
26306 }
26307 {
26308 resultobj = SWIG_From_int((int)(result));
26309 }
26310 return resultobj;
26311 fail:
26312 return NULL;
26313 }
26314
26315
26316 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26317 PyObject *resultobj;
26318 wxWindow *arg1 = (wxWindow *) 0 ;
26319 wxSize *arg2 = 0 ;
26320 wxSize temp2 ;
26321 PyObject * obj0 = 0 ;
26322 PyObject * obj1 = 0 ;
26323 char *kwnames[] = {
26324 (char *) "self",(char *) "size", NULL
26325 };
26326
26327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26329 if (SWIG_arg_fail(1)) SWIG_fail;
26330 {
26331 arg2 = &temp2;
26332 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26333 }
26334 {
26335 PyThreadState* __tstate = wxPyBeginAllowThreads();
26336 (arg1)->SetSize((wxSize const &)*arg2);
26337
26338 wxPyEndAllowThreads(__tstate);
26339 if (PyErr_Occurred()) SWIG_fail;
26340 }
26341 Py_INCREF(Py_None); resultobj = Py_None;
26342 return resultobj;
26343 fail:
26344 return NULL;
26345 }
26346
26347
26348 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26349 PyObject *resultobj;
26350 wxWindow *arg1 = (wxWindow *) 0 ;
26351 int arg2 ;
26352 int arg3 ;
26353 int arg4 ;
26354 int arg5 ;
26355 int arg6 = (int) wxSIZE_AUTO ;
26356 PyObject * obj0 = 0 ;
26357 PyObject * obj1 = 0 ;
26358 PyObject * obj2 = 0 ;
26359 PyObject * obj3 = 0 ;
26360 PyObject * obj4 = 0 ;
26361 PyObject * obj5 = 0 ;
26362 char *kwnames[] = {
26363 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26364 };
26365
26366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26368 if (SWIG_arg_fail(1)) SWIG_fail;
26369 {
26370 arg2 = (int)(SWIG_As_int(obj1));
26371 if (SWIG_arg_fail(2)) SWIG_fail;
26372 }
26373 {
26374 arg3 = (int)(SWIG_As_int(obj2));
26375 if (SWIG_arg_fail(3)) SWIG_fail;
26376 }
26377 {
26378 arg4 = (int)(SWIG_As_int(obj3));
26379 if (SWIG_arg_fail(4)) SWIG_fail;
26380 }
26381 {
26382 arg5 = (int)(SWIG_As_int(obj4));
26383 if (SWIG_arg_fail(5)) SWIG_fail;
26384 }
26385 if (obj5) {
26386 {
26387 arg6 = (int)(SWIG_As_int(obj5));
26388 if (SWIG_arg_fail(6)) SWIG_fail;
26389 }
26390 }
26391 {
26392 PyThreadState* __tstate = wxPyBeginAllowThreads();
26393 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26394
26395 wxPyEndAllowThreads(__tstate);
26396 if (PyErr_Occurred()) SWIG_fail;
26397 }
26398 Py_INCREF(Py_None); resultobj = Py_None;
26399 return resultobj;
26400 fail:
26401 return NULL;
26402 }
26403
26404
26405 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26406 PyObject *resultobj;
26407 wxWindow *arg1 = (wxWindow *) 0 ;
26408 wxRect *arg2 = 0 ;
26409 int arg3 = (int) wxSIZE_AUTO ;
26410 wxRect temp2 ;
26411 PyObject * obj0 = 0 ;
26412 PyObject * obj1 = 0 ;
26413 PyObject * obj2 = 0 ;
26414 char *kwnames[] = {
26415 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26416 };
26417
26418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26420 if (SWIG_arg_fail(1)) SWIG_fail;
26421 {
26422 arg2 = &temp2;
26423 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26424 }
26425 if (obj2) {
26426 {
26427 arg3 = (int)(SWIG_As_int(obj2));
26428 if (SWIG_arg_fail(3)) SWIG_fail;
26429 }
26430 }
26431 {
26432 PyThreadState* __tstate = wxPyBeginAllowThreads();
26433 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26434
26435 wxPyEndAllowThreads(__tstate);
26436 if (PyErr_Occurred()) SWIG_fail;
26437 }
26438 Py_INCREF(Py_None); resultobj = Py_None;
26439 return resultobj;
26440 fail:
26441 return NULL;
26442 }
26443
26444
26445 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26446 PyObject *resultobj;
26447 wxWindow *arg1 = (wxWindow *) 0 ;
26448 int arg2 ;
26449 int arg3 ;
26450 PyObject * obj0 = 0 ;
26451 PyObject * obj1 = 0 ;
26452 PyObject * obj2 = 0 ;
26453 char *kwnames[] = {
26454 (char *) "self",(char *) "width",(char *) "height", NULL
26455 };
26456
26457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26459 if (SWIG_arg_fail(1)) SWIG_fail;
26460 {
26461 arg2 = (int)(SWIG_As_int(obj1));
26462 if (SWIG_arg_fail(2)) SWIG_fail;
26463 }
26464 {
26465 arg3 = (int)(SWIG_As_int(obj2));
26466 if (SWIG_arg_fail(3)) SWIG_fail;
26467 }
26468 {
26469 PyThreadState* __tstate = wxPyBeginAllowThreads();
26470 (arg1)->SetSize(arg2,arg3);
26471
26472 wxPyEndAllowThreads(__tstate);
26473 if (PyErr_Occurred()) SWIG_fail;
26474 }
26475 Py_INCREF(Py_None); resultobj = Py_None;
26476 return resultobj;
26477 fail:
26478 return NULL;
26479 }
26480
26481
26482 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26483 PyObject *resultobj;
26484 wxWindow *arg1 = (wxWindow *) 0 ;
26485 wxPoint *arg2 = 0 ;
26486 int arg3 = (int) wxSIZE_USE_EXISTING ;
26487 wxPoint temp2 ;
26488 PyObject * obj0 = 0 ;
26489 PyObject * obj1 = 0 ;
26490 PyObject * obj2 = 0 ;
26491 char *kwnames[] = {
26492 (char *) "self",(char *) "pt",(char *) "flags", NULL
26493 };
26494
26495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26497 if (SWIG_arg_fail(1)) SWIG_fail;
26498 {
26499 arg2 = &temp2;
26500 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26501 }
26502 if (obj2) {
26503 {
26504 arg3 = (int)(SWIG_As_int(obj2));
26505 if (SWIG_arg_fail(3)) SWIG_fail;
26506 }
26507 }
26508 {
26509 PyThreadState* __tstate = wxPyBeginAllowThreads();
26510 (arg1)->Move((wxPoint const &)*arg2,arg3);
26511
26512 wxPyEndAllowThreads(__tstate);
26513 if (PyErr_Occurred()) SWIG_fail;
26514 }
26515 Py_INCREF(Py_None); resultobj = Py_None;
26516 return resultobj;
26517 fail:
26518 return NULL;
26519 }
26520
26521
26522 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26523 PyObject *resultobj;
26524 wxWindow *arg1 = (wxWindow *) 0 ;
26525 int arg2 ;
26526 int arg3 ;
26527 int arg4 = (int) wxSIZE_USE_EXISTING ;
26528 PyObject * obj0 = 0 ;
26529 PyObject * obj1 = 0 ;
26530 PyObject * obj2 = 0 ;
26531 PyObject * obj3 = 0 ;
26532 char *kwnames[] = {
26533 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26534 };
26535
26536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26538 if (SWIG_arg_fail(1)) SWIG_fail;
26539 {
26540 arg2 = (int)(SWIG_As_int(obj1));
26541 if (SWIG_arg_fail(2)) SWIG_fail;
26542 }
26543 {
26544 arg3 = (int)(SWIG_As_int(obj2));
26545 if (SWIG_arg_fail(3)) SWIG_fail;
26546 }
26547 if (obj3) {
26548 {
26549 arg4 = (int)(SWIG_As_int(obj3));
26550 if (SWIG_arg_fail(4)) SWIG_fail;
26551 }
26552 }
26553 {
26554 PyThreadState* __tstate = wxPyBeginAllowThreads();
26555 (arg1)->Move(arg2,arg3,arg4);
26556
26557 wxPyEndAllowThreads(__tstate);
26558 if (PyErr_Occurred()) SWIG_fail;
26559 }
26560 Py_INCREF(Py_None); resultobj = Py_None;
26561 return resultobj;
26562 fail:
26563 return NULL;
26564 }
26565
26566
26567 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26568 PyObject *resultobj;
26569 wxWindow *arg1 = (wxWindow *) 0 ;
26570 wxSize const &arg2_defvalue = wxDefaultSize ;
26571 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26572 wxSize temp2 ;
26573 PyObject * obj0 = 0 ;
26574 PyObject * obj1 = 0 ;
26575 char *kwnames[] = {
26576 (char *) "self",(char *) "size", NULL
26577 };
26578
26579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26581 if (SWIG_arg_fail(1)) SWIG_fail;
26582 if (obj1) {
26583 {
26584 arg2 = &temp2;
26585 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26586 }
26587 }
26588 {
26589 PyThreadState* __tstate = wxPyBeginAllowThreads();
26590 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26591
26592 wxPyEndAllowThreads(__tstate);
26593 if (PyErr_Occurred()) SWIG_fail;
26594 }
26595 Py_INCREF(Py_None); resultobj = Py_None;
26596 return resultobj;
26597 fail:
26598 return NULL;
26599 }
26600
26601
26602 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26603 PyObject *resultobj;
26604 wxWindow *arg1 = (wxWindow *) 0 ;
26605 PyObject * obj0 = 0 ;
26606 char *kwnames[] = {
26607 (char *) "self", NULL
26608 };
26609
26610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26612 if (SWIG_arg_fail(1)) SWIG_fail;
26613 {
26614 PyThreadState* __tstate = wxPyBeginAllowThreads();
26615 (arg1)->Raise();
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_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26628 PyObject *resultobj;
26629 wxWindow *arg1 = (wxWindow *) 0 ;
26630 PyObject * obj0 = 0 ;
26631 char *kwnames[] = {
26632 (char *) "self", NULL
26633 };
26634
26635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26637 if (SWIG_arg_fail(1)) SWIG_fail;
26638 {
26639 PyThreadState* __tstate = wxPyBeginAllowThreads();
26640 (arg1)->Lower();
26641
26642 wxPyEndAllowThreads(__tstate);
26643 if (PyErr_Occurred()) SWIG_fail;
26644 }
26645 Py_INCREF(Py_None); resultobj = Py_None;
26646 return resultobj;
26647 fail:
26648 return NULL;
26649 }
26650
26651
26652 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26653 PyObject *resultobj;
26654 wxWindow *arg1 = (wxWindow *) 0 ;
26655 wxSize *arg2 = 0 ;
26656 wxSize temp2 ;
26657 PyObject * obj0 = 0 ;
26658 PyObject * obj1 = 0 ;
26659 char *kwnames[] = {
26660 (char *) "self",(char *) "size", NULL
26661 };
26662
26663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26665 if (SWIG_arg_fail(1)) SWIG_fail;
26666 {
26667 arg2 = &temp2;
26668 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26669 }
26670 {
26671 PyThreadState* __tstate = wxPyBeginAllowThreads();
26672 (arg1)->SetClientSize((wxSize const &)*arg2);
26673
26674 wxPyEndAllowThreads(__tstate);
26675 if (PyErr_Occurred()) SWIG_fail;
26676 }
26677 Py_INCREF(Py_None); resultobj = Py_None;
26678 return resultobj;
26679 fail:
26680 return NULL;
26681 }
26682
26683
26684 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26685 PyObject *resultobj;
26686 wxWindow *arg1 = (wxWindow *) 0 ;
26687 int arg2 ;
26688 int arg3 ;
26689 PyObject * obj0 = 0 ;
26690 PyObject * obj1 = 0 ;
26691 PyObject * obj2 = 0 ;
26692 char *kwnames[] = {
26693 (char *) "self",(char *) "width",(char *) "height", NULL
26694 };
26695
26696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26698 if (SWIG_arg_fail(1)) SWIG_fail;
26699 {
26700 arg2 = (int)(SWIG_As_int(obj1));
26701 if (SWIG_arg_fail(2)) SWIG_fail;
26702 }
26703 {
26704 arg3 = (int)(SWIG_As_int(obj2));
26705 if (SWIG_arg_fail(3)) SWIG_fail;
26706 }
26707 {
26708 PyThreadState* __tstate = wxPyBeginAllowThreads();
26709 (arg1)->SetClientSize(arg2,arg3);
26710
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 Py_INCREF(Py_None); resultobj = Py_None;
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26722 PyObject *resultobj;
26723 wxWindow *arg1 = (wxWindow *) 0 ;
26724 wxRect *arg2 = 0 ;
26725 wxRect temp2 ;
26726 PyObject * obj0 = 0 ;
26727 PyObject * obj1 = 0 ;
26728 char *kwnames[] = {
26729 (char *) "self",(char *) "rect", NULL
26730 };
26731
26732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26734 if (SWIG_arg_fail(1)) SWIG_fail;
26735 {
26736 arg2 = &temp2;
26737 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26738 }
26739 {
26740 PyThreadState* __tstate = wxPyBeginAllowThreads();
26741 (arg1)->SetClientSize((wxRect const &)*arg2);
26742
26743 wxPyEndAllowThreads(__tstate);
26744 if (PyErr_Occurred()) SWIG_fail;
26745 }
26746 Py_INCREF(Py_None); resultobj = Py_None;
26747 return resultobj;
26748 fail:
26749 return NULL;
26750 }
26751
26752
26753 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26754 PyObject *resultobj;
26755 wxWindow *arg1 = (wxWindow *) 0 ;
26756 wxPoint result;
26757 PyObject * obj0 = 0 ;
26758 char *kwnames[] = {
26759 (char *) "self", NULL
26760 };
26761
26762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26764 if (SWIG_arg_fail(1)) SWIG_fail;
26765 {
26766 PyThreadState* __tstate = wxPyBeginAllowThreads();
26767 result = (arg1)->GetPosition();
26768
26769 wxPyEndAllowThreads(__tstate);
26770 if (PyErr_Occurred()) SWIG_fail;
26771 }
26772 {
26773 wxPoint * resultptr;
26774 resultptr = new wxPoint((wxPoint &)(result));
26775 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26776 }
26777 return resultobj;
26778 fail:
26779 return NULL;
26780 }
26781
26782
26783 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26784 PyObject *resultobj;
26785 wxWindow *arg1 = (wxWindow *) 0 ;
26786 int *arg2 = (int *) 0 ;
26787 int *arg3 = (int *) 0 ;
26788 int temp2 ;
26789 int res2 = 0 ;
26790 int temp3 ;
26791 int res3 = 0 ;
26792 PyObject * obj0 = 0 ;
26793 char *kwnames[] = {
26794 (char *) "self", NULL
26795 };
26796
26797 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26798 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26801 if (SWIG_arg_fail(1)) SWIG_fail;
26802 {
26803 PyThreadState* __tstate = wxPyBeginAllowThreads();
26804 (arg1)->GetPosition(arg2,arg3);
26805
26806 wxPyEndAllowThreads(__tstate);
26807 if (PyErr_Occurred()) SWIG_fail;
26808 }
26809 Py_INCREF(Py_None); resultobj = Py_None;
26810 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26811 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26812 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26813 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26814 return resultobj;
26815 fail:
26816 return NULL;
26817 }
26818
26819
26820 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26821 PyObject *resultobj;
26822 wxWindow *arg1 = (wxWindow *) 0 ;
26823 wxSize result;
26824 PyObject * obj0 = 0 ;
26825 char *kwnames[] = {
26826 (char *) "self", NULL
26827 };
26828
26829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26831 if (SWIG_arg_fail(1)) SWIG_fail;
26832 {
26833 PyThreadState* __tstate = wxPyBeginAllowThreads();
26834 result = ((wxWindow const *)arg1)->GetSize();
26835
26836 wxPyEndAllowThreads(__tstate);
26837 if (PyErr_Occurred()) SWIG_fail;
26838 }
26839 {
26840 wxSize * resultptr;
26841 resultptr = new wxSize((wxSize &)(result));
26842 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26843 }
26844 return resultobj;
26845 fail:
26846 return NULL;
26847 }
26848
26849
26850 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26851 PyObject *resultobj;
26852 wxWindow *arg1 = (wxWindow *) 0 ;
26853 int *arg2 = (int *) 0 ;
26854 int *arg3 = (int *) 0 ;
26855 int temp2 ;
26856 int res2 = 0 ;
26857 int temp3 ;
26858 int res3 = 0 ;
26859 PyObject * obj0 = 0 ;
26860 char *kwnames[] = {
26861 (char *) "self", NULL
26862 };
26863
26864 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26865 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26868 if (SWIG_arg_fail(1)) SWIG_fail;
26869 {
26870 PyThreadState* __tstate = wxPyBeginAllowThreads();
26871 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26872
26873 wxPyEndAllowThreads(__tstate);
26874 if (PyErr_Occurred()) SWIG_fail;
26875 }
26876 Py_INCREF(Py_None); resultobj = Py_None;
26877 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26878 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26879 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26880 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26888 PyObject *resultobj;
26889 wxWindow *arg1 = (wxWindow *) 0 ;
26890 wxRect result;
26891 PyObject * obj0 = 0 ;
26892 char *kwnames[] = {
26893 (char *) "self", NULL
26894 };
26895
26896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26898 if (SWIG_arg_fail(1)) SWIG_fail;
26899 {
26900 PyThreadState* __tstate = wxPyBeginAllowThreads();
26901 result = ((wxWindow const *)arg1)->GetRect();
26902
26903 wxPyEndAllowThreads(__tstate);
26904 if (PyErr_Occurred()) SWIG_fail;
26905 }
26906 {
26907 wxRect * resultptr;
26908 resultptr = new wxRect((wxRect &)(result));
26909 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26910 }
26911 return resultobj;
26912 fail:
26913 return NULL;
26914 }
26915
26916
26917 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26918 PyObject *resultobj;
26919 wxWindow *arg1 = (wxWindow *) 0 ;
26920 wxSize result;
26921 PyObject * obj0 = 0 ;
26922 char *kwnames[] = {
26923 (char *) "self", NULL
26924 };
26925
26926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26928 if (SWIG_arg_fail(1)) SWIG_fail;
26929 {
26930 PyThreadState* __tstate = wxPyBeginAllowThreads();
26931 result = ((wxWindow const *)arg1)->GetClientSize();
26932
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 {
26937 wxSize * resultptr;
26938 resultptr = new wxSize((wxSize &)(result));
26939 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26940 }
26941 return resultobj;
26942 fail:
26943 return NULL;
26944 }
26945
26946
26947 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26948 PyObject *resultobj;
26949 wxWindow *arg1 = (wxWindow *) 0 ;
26950 int *arg2 = (int *) 0 ;
26951 int *arg3 = (int *) 0 ;
26952 int temp2 ;
26953 int res2 = 0 ;
26954 int temp3 ;
26955 int res3 = 0 ;
26956 PyObject * obj0 = 0 ;
26957 char *kwnames[] = {
26958 (char *) "self", NULL
26959 };
26960
26961 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26962 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26965 if (SWIG_arg_fail(1)) SWIG_fail;
26966 {
26967 PyThreadState* __tstate = wxPyBeginAllowThreads();
26968 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26969
26970 wxPyEndAllowThreads(__tstate);
26971 if (PyErr_Occurred()) SWIG_fail;
26972 }
26973 Py_INCREF(Py_None); resultobj = Py_None;
26974 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26975 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26976 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26977 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26978 return resultobj;
26979 fail:
26980 return NULL;
26981 }
26982
26983
26984 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26985 PyObject *resultobj;
26986 wxWindow *arg1 = (wxWindow *) 0 ;
26987 wxPoint result;
26988 PyObject * obj0 = 0 ;
26989 char *kwnames[] = {
26990 (char *) "self", NULL
26991 };
26992
26993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26995 if (SWIG_arg_fail(1)) SWIG_fail;
26996 {
26997 PyThreadState* __tstate = wxPyBeginAllowThreads();
26998 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26999
27000 wxPyEndAllowThreads(__tstate);
27001 if (PyErr_Occurred()) SWIG_fail;
27002 }
27003 {
27004 wxPoint * resultptr;
27005 resultptr = new wxPoint((wxPoint &)(result));
27006 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27007 }
27008 return resultobj;
27009 fail:
27010 return NULL;
27011 }
27012
27013
27014 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
27015 PyObject *resultobj;
27016 wxWindow *arg1 = (wxWindow *) 0 ;
27017 wxRect result;
27018 PyObject * obj0 = 0 ;
27019 char *kwnames[] = {
27020 (char *) "self", NULL
27021 };
27022
27023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
27024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27025 if (SWIG_arg_fail(1)) SWIG_fail;
27026 {
27027 PyThreadState* __tstate = wxPyBeginAllowThreads();
27028 result = ((wxWindow const *)arg1)->GetClientRect();
27029
27030 wxPyEndAllowThreads(__tstate);
27031 if (PyErr_Occurred()) SWIG_fail;
27032 }
27033 {
27034 wxRect * resultptr;
27035 resultptr = new wxRect((wxRect &)(result));
27036 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27037 }
27038 return resultobj;
27039 fail:
27040 return NULL;
27041 }
27042
27043
27044 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27045 PyObject *resultobj;
27046 wxWindow *arg1 = (wxWindow *) 0 ;
27047 wxSize result;
27048 PyObject * obj0 = 0 ;
27049 char *kwnames[] = {
27050 (char *) "self", NULL
27051 };
27052
27053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
27054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27055 if (SWIG_arg_fail(1)) SWIG_fail;
27056 {
27057 PyThreadState* __tstate = wxPyBeginAllowThreads();
27058 result = ((wxWindow const *)arg1)->GetBestSize();
27059
27060 wxPyEndAllowThreads(__tstate);
27061 if (PyErr_Occurred()) SWIG_fail;
27062 }
27063 {
27064 wxSize * resultptr;
27065 resultptr = new wxSize((wxSize &)(result));
27066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27067 }
27068 return resultobj;
27069 fail:
27070 return NULL;
27071 }
27072
27073
27074 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27075 PyObject *resultobj;
27076 wxWindow *arg1 = (wxWindow *) 0 ;
27077 int *arg2 = (int *) 0 ;
27078 int *arg3 = (int *) 0 ;
27079 int temp2 ;
27080 int res2 = 0 ;
27081 int temp3 ;
27082 int res3 = 0 ;
27083 PyObject * obj0 = 0 ;
27084 char *kwnames[] = {
27085 (char *) "self", NULL
27086 };
27087
27088 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27089 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27092 if (SWIG_arg_fail(1)) SWIG_fail;
27093 {
27094 PyThreadState* __tstate = wxPyBeginAllowThreads();
27095 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27096
27097 wxPyEndAllowThreads(__tstate);
27098 if (PyErr_Occurred()) SWIG_fail;
27099 }
27100 Py_INCREF(Py_None); resultobj = Py_None;
27101 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27102 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27103 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27104 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27105 return resultobj;
27106 fail:
27107 return NULL;
27108 }
27109
27110
27111 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27112 PyObject *resultobj;
27113 wxWindow *arg1 = (wxWindow *) 0 ;
27114 PyObject * obj0 = 0 ;
27115 char *kwnames[] = {
27116 (char *) "self", NULL
27117 };
27118
27119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
27120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27121 if (SWIG_arg_fail(1)) SWIG_fail;
27122 {
27123 PyThreadState* __tstate = wxPyBeginAllowThreads();
27124 (arg1)->InvalidateBestSize();
27125
27126 wxPyEndAllowThreads(__tstate);
27127 if (PyErr_Occurred()) SWIG_fail;
27128 }
27129 Py_INCREF(Py_None); resultobj = Py_None;
27130 return resultobj;
27131 fail:
27132 return NULL;
27133 }
27134
27135
27136 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27137 PyObject *resultobj;
27138 wxWindow *arg1 = (wxWindow *) 0 ;
27139 wxSize *arg2 = 0 ;
27140 wxSize temp2 ;
27141 PyObject * obj0 = 0 ;
27142 PyObject * obj1 = 0 ;
27143 char *kwnames[] = {
27144 (char *) "self",(char *) "size", NULL
27145 };
27146
27147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27149 if (SWIG_arg_fail(1)) SWIG_fail;
27150 {
27151 arg2 = &temp2;
27152 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27153 }
27154 {
27155 PyThreadState* __tstate = wxPyBeginAllowThreads();
27156 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27157
27158 wxPyEndAllowThreads(__tstate);
27159 if (PyErr_Occurred()) SWIG_fail;
27160 }
27161 Py_INCREF(Py_None); resultobj = Py_None;
27162 return resultobj;
27163 fail:
27164 return NULL;
27165 }
27166
27167
27168 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27169 PyObject *resultobj;
27170 wxWindow *arg1 = (wxWindow *) 0 ;
27171 wxSize result;
27172 PyObject * obj0 = 0 ;
27173 char *kwnames[] = {
27174 (char *) "self", NULL
27175 };
27176
27177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27179 if (SWIG_arg_fail(1)) SWIG_fail;
27180 {
27181 PyThreadState* __tstate = wxPyBeginAllowThreads();
27182 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27183
27184 wxPyEndAllowThreads(__tstate);
27185 if (PyErr_Occurred()) SWIG_fail;
27186 }
27187 {
27188 wxSize * resultptr;
27189 resultptr = new wxSize((wxSize &)(result));
27190 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27191 }
27192 return resultobj;
27193 fail:
27194 return NULL;
27195 }
27196
27197
27198 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27199 PyObject *resultobj;
27200 wxWindow *arg1 = (wxWindow *) 0 ;
27201 wxSize result;
27202 PyObject * obj0 = 0 ;
27203 char *kwnames[] = {
27204 (char *) "self", NULL
27205 };
27206
27207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27209 if (SWIG_arg_fail(1)) SWIG_fail;
27210 {
27211 PyThreadState* __tstate = wxPyBeginAllowThreads();
27212 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27213
27214 wxPyEndAllowThreads(__tstate);
27215 if (PyErr_Occurred()) SWIG_fail;
27216 }
27217 {
27218 wxSize * resultptr;
27219 resultptr = new wxSize((wxSize &)(result));
27220 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27221 }
27222 return resultobj;
27223 fail:
27224 return NULL;
27225 }
27226
27227
27228 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27229 PyObject *resultobj;
27230 wxWindow *arg1 = (wxWindow *) 0 ;
27231 int arg2 = (int) wxBOTH ;
27232 PyObject * obj0 = 0 ;
27233 PyObject * obj1 = 0 ;
27234 char *kwnames[] = {
27235 (char *) "self",(char *) "direction", NULL
27236 };
27237
27238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27240 if (SWIG_arg_fail(1)) SWIG_fail;
27241 if (obj1) {
27242 {
27243 arg2 = (int)(SWIG_As_int(obj1));
27244 if (SWIG_arg_fail(2)) SWIG_fail;
27245 }
27246 }
27247 {
27248 PyThreadState* __tstate = wxPyBeginAllowThreads();
27249 (arg1)->Center(arg2);
27250
27251 wxPyEndAllowThreads(__tstate);
27252 if (PyErr_Occurred()) SWIG_fail;
27253 }
27254 Py_INCREF(Py_None); resultobj = Py_None;
27255 return resultobj;
27256 fail:
27257 return NULL;
27258 }
27259
27260
27261 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
27262 PyObject *resultobj;
27263 wxWindow *arg1 = (wxWindow *) 0 ;
27264 int arg2 = (int) wxBOTH ;
27265 PyObject * obj0 = 0 ;
27266 PyObject * obj1 = 0 ;
27267 char *kwnames[] = {
27268 (char *) "self",(char *) "dir", NULL
27269 };
27270
27271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
27272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27273 if (SWIG_arg_fail(1)) SWIG_fail;
27274 if (obj1) {
27275 {
27276 arg2 = (int)(SWIG_As_int(obj1));
27277 if (SWIG_arg_fail(2)) SWIG_fail;
27278 }
27279 }
27280 {
27281 PyThreadState* __tstate = wxPyBeginAllowThreads();
27282 (arg1)->CenterOnScreen(arg2);
27283
27284 wxPyEndAllowThreads(__tstate);
27285 if (PyErr_Occurred()) SWIG_fail;
27286 }
27287 Py_INCREF(Py_None); resultobj = Py_None;
27288 return resultobj;
27289 fail:
27290 return NULL;
27291 }
27292
27293
27294 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27295 PyObject *resultobj;
27296 wxWindow *arg1 = (wxWindow *) 0 ;
27297 int arg2 = (int) wxBOTH ;
27298 PyObject * obj0 = 0 ;
27299 PyObject * obj1 = 0 ;
27300 char *kwnames[] = {
27301 (char *) "self",(char *) "dir", NULL
27302 };
27303
27304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27306 if (SWIG_arg_fail(1)) SWIG_fail;
27307 if (obj1) {
27308 {
27309 arg2 = (int)(SWIG_As_int(obj1));
27310 if (SWIG_arg_fail(2)) SWIG_fail;
27311 }
27312 }
27313 {
27314 PyThreadState* __tstate = wxPyBeginAllowThreads();
27315 (arg1)->CenterOnParent(arg2);
27316
27317 wxPyEndAllowThreads(__tstate);
27318 if (PyErr_Occurred()) SWIG_fail;
27319 }
27320 Py_INCREF(Py_None); resultobj = Py_None;
27321 return resultobj;
27322 fail:
27323 return NULL;
27324 }
27325
27326
27327 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27328 PyObject *resultobj;
27329 wxWindow *arg1 = (wxWindow *) 0 ;
27330 PyObject * obj0 = 0 ;
27331 char *kwnames[] = {
27332 (char *) "self", NULL
27333 };
27334
27335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27337 if (SWIG_arg_fail(1)) SWIG_fail;
27338 {
27339 PyThreadState* __tstate = wxPyBeginAllowThreads();
27340 (arg1)->Fit();
27341
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 Py_INCREF(Py_None); resultobj = Py_None;
27346 return resultobj;
27347 fail:
27348 return NULL;
27349 }
27350
27351
27352 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27353 PyObject *resultobj;
27354 wxWindow *arg1 = (wxWindow *) 0 ;
27355 PyObject * obj0 = 0 ;
27356 char *kwnames[] = {
27357 (char *) "self", NULL
27358 };
27359
27360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27362 if (SWIG_arg_fail(1)) SWIG_fail;
27363 {
27364 PyThreadState* __tstate = wxPyBeginAllowThreads();
27365 (arg1)->FitInside();
27366
27367 wxPyEndAllowThreads(__tstate);
27368 if (PyErr_Occurred()) SWIG_fail;
27369 }
27370 Py_INCREF(Py_None); resultobj = Py_None;
27371 return resultobj;
27372 fail:
27373 return NULL;
27374 }
27375
27376
27377 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27378 PyObject *resultobj;
27379 wxWindow *arg1 = (wxWindow *) 0 ;
27380 int arg2 ;
27381 int arg3 ;
27382 int arg4 = (int) -1 ;
27383 int arg5 = (int) -1 ;
27384 int arg6 = (int) -1 ;
27385 int arg7 = (int) -1 ;
27386 PyObject * obj0 = 0 ;
27387 PyObject * obj1 = 0 ;
27388 PyObject * obj2 = 0 ;
27389 PyObject * obj3 = 0 ;
27390 PyObject * obj4 = 0 ;
27391 PyObject * obj5 = 0 ;
27392 PyObject * obj6 = 0 ;
27393 char *kwnames[] = {
27394 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27395 };
27396
27397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27399 if (SWIG_arg_fail(1)) SWIG_fail;
27400 {
27401 arg2 = (int)(SWIG_As_int(obj1));
27402 if (SWIG_arg_fail(2)) SWIG_fail;
27403 }
27404 {
27405 arg3 = (int)(SWIG_As_int(obj2));
27406 if (SWIG_arg_fail(3)) SWIG_fail;
27407 }
27408 if (obj3) {
27409 {
27410 arg4 = (int)(SWIG_As_int(obj3));
27411 if (SWIG_arg_fail(4)) SWIG_fail;
27412 }
27413 }
27414 if (obj4) {
27415 {
27416 arg5 = (int)(SWIG_As_int(obj4));
27417 if (SWIG_arg_fail(5)) SWIG_fail;
27418 }
27419 }
27420 if (obj5) {
27421 {
27422 arg6 = (int)(SWIG_As_int(obj5));
27423 if (SWIG_arg_fail(6)) SWIG_fail;
27424 }
27425 }
27426 if (obj6) {
27427 {
27428 arg7 = (int)(SWIG_As_int(obj6));
27429 if (SWIG_arg_fail(7)) SWIG_fail;
27430 }
27431 }
27432 {
27433 PyThreadState* __tstate = wxPyBeginAllowThreads();
27434 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27435
27436 wxPyEndAllowThreads(__tstate);
27437 if (PyErr_Occurred()) SWIG_fail;
27438 }
27439 Py_INCREF(Py_None); resultobj = Py_None;
27440 return resultobj;
27441 fail:
27442 return NULL;
27443 }
27444
27445
27446 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27447 PyObject *resultobj;
27448 wxWindow *arg1 = (wxWindow *) 0 ;
27449 wxSize *arg2 = 0 ;
27450 wxSize const &arg3_defvalue = wxDefaultSize ;
27451 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27452 wxSize const &arg4_defvalue = wxDefaultSize ;
27453 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27454 wxSize temp2 ;
27455 wxSize temp3 ;
27456 wxSize temp4 ;
27457 PyObject * obj0 = 0 ;
27458 PyObject * obj1 = 0 ;
27459 PyObject * obj2 = 0 ;
27460 PyObject * obj3 = 0 ;
27461 char *kwnames[] = {
27462 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27463 };
27464
27465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27467 if (SWIG_arg_fail(1)) SWIG_fail;
27468 {
27469 arg2 = &temp2;
27470 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27471 }
27472 if (obj2) {
27473 {
27474 arg3 = &temp3;
27475 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27476 }
27477 }
27478 if (obj3) {
27479 {
27480 arg4 = &temp4;
27481 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27482 }
27483 }
27484 {
27485 PyThreadState* __tstate = wxPyBeginAllowThreads();
27486 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27487
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 Py_INCREF(Py_None); resultobj = Py_None;
27492 return resultobj;
27493 fail:
27494 return NULL;
27495 }
27496
27497
27498 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27499 PyObject *resultobj;
27500 wxWindow *arg1 = (wxWindow *) 0 ;
27501 int arg2 ;
27502 int arg3 ;
27503 int arg4 = (int) -1 ;
27504 int arg5 = (int) -1 ;
27505 PyObject * obj0 = 0 ;
27506 PyObject * obj1 = 0 ;
27507 PyObject * obj2 = 0 ;
27508 PyObject * obj3 = 0 ;
27509 PyObject * obj4 = 0 ;
27510 char *kwnames[] = {
27511 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27512 };
27513
27514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27516 if (SWIG_arg_fail(1)) SWIG_fail;
27517 {
27518 arg2 = (int)(SWIG_As_int(obj1));
27519 if (SWIG_arg_fail(2)) SWIG_fail;
27520 }
27521 {
27522 arg3 = (int)(SWIG_As_int(obj2));
27523 if (SWIG_arg_fail(3)) SWIG_fail;
27524 }
27525 if (obj3) {
27526 {
27527 arg4 = (int)(SWIG_As_int(obj3));
27528 if (SWIG_arg_fail(4)) SWIG_fail;
27529 }
27530 }
27531 if (obj4) {
27532 {
27533 arg5 = (int)(SWIG_As_int(obj4));
27534 if (SWIG_arg_fail(5)) SWIG_fail;
27535 }
27536 }
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27540
27541 wxPyEndAllowThreads(__tstate);
27542 if (PyErr_Occurred()) SWIG_fail;
27543 }
27544 Py_INCREF(Py_None); resultobj = Py_None;
27545 return resultobj;
27546 fail:
27547 return NULL;
27548 }
27549
27550
27551 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27552 PyObject *resultobj;
27553 wxWindow *arg1 = (wxWindow *) 0 ;
27554 wxSize *arg2 = 0 ;
27555 wxSize const &arg3_defvalue = wxDefaultSize ;
27556 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27557 wxSize temp2 ;
27558 wxSize temp3 ;
27559 PyObject * obj0 = 0 ;
27560 PyObject * obj1 = 0 ;
27561 PyObject * obj2 = 0 ;
27562 char *kwnames[] = {
27563 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27564 };
27565
27566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27568 if (SWIG_arg_fail(1)) SWIG_fail;
27569 {
27570 arg2 = &temp2;
27571 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27572 }
27573 if (obj2) {
27574 {
27575 arg3 = &temp3;
27576 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27577 }
27578 }
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27582
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 Py_INCREF(Py_None); resultobj = Py_None;
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj;
27595 wxWindow *arg1 = (wxWindow *) 0 ;
27596 wxSize result;
27597 PyObject * obj0 = 0 ;
27598 char *kwnames[] = {
27599 (char *) "self", NULL
27600 };
27601
27602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27604 if (SWIG_arg_fail(1)) SWIG_fail;
27605 {
27606 PyThreadState* __tstate = wxPyBeginAllowThreads();
27607 result = ((wxWindow const *)arg1)->GetMaxSize();
27608
27609 wxPyEndAllowThreads(__tstate);
27610 if (PyErr_Occurred()) SWIG_fail;
27611 }
27612 {
27613 wxSize * resultptr;
27614 resultptr = new wxSize((wxSize &)(result));
27615 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27616 }
27617 return resultobj;
27618 fail:
27619 return NULL;
27620 }
27621
27622
27623 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27624 PyObject *resultobj;
27625 wxWindow *arg1 = (wxWindow *) 0 ;
27626 wxSize result;
27627 PyObject * obj0 = 0 ;
27628 char *kwnames[] = {
27629 (char *) "self", NULL
27630 };
27631
27632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27634 if (SWIG_arg_fail(1)) SWIG_fail;
27635 {
27636 PyThreadState* __tstate = wxPyBeginAllowThreads();
27637 result = ((wxWindow const *)arg1)->GetMinSize();
27638
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 {
27643 wxSize * resultptr;
27644 resultptr = new wxSize((wxSize &)(result));
27645 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27646 }
27647 return resultobj;
27648 fail:
27649 return NULL;
27650 }
27651
27652
27653 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27654 PyObject *resultobj;
27655 wxWindow *arg1 = (wxWindow *) 0 ;
27656 wxSize *arg2 = 0 ;
27657 wxSize temp2 ;
27658 PyObject * obj0 = 0 ;
27659 PyObject * obj1 = 0 ;
27660 char *kwnames[] = {
27661 (char *) "self",(char *) "minSize", NULL
27662 };
27663
27664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27666 if (SWIG_arg_fail(1)) SWIG_fail;
27667 {
27668 arg2 = &temp2;
27669 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27670 }
27671 {
27672 PyThreadState* __tstate = wxPyBeginAllowThreads();
27673 (arg1)->SetMinSize((wxSize const &)*arg2);
27674
27675 wxPyEndAllowThreads(__tstate);
27676 if (PyErr_Occurred()) SWIG_fail;
27677 }
27678 Py_INCREF(Py_None); resultobj = Py_None;
27679 return resultobj;
27680 fail:
27681 return NULL;
27682 }
27683
27684
27685 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27686 PyObject *resultobj;
27687 wxWindow *arg1 = (wxWindow *) 0 ;
27688 wxSize *arg2 = 0 ;
27689 wxSize temp2 ;
27690 PyObject * obj0 = 0 ;
27691 PyObject * obj1 = 0 ;
27692 char *kwnames[] = {
27693 (char *) "self",(char *) "maxSize", NULL
27694 };
27695
27696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27698 if (SWIG_arg_fail(1)) SWIG_fail;
27699 {
27700 arg2 = &temp2;
27701 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27702 }
27703 {
27704 PyThreadState* __tstate = wxPyBeginAllowThreads();
27705 (arg1)->SetMaxSize((wxSize const &)*arg2);
27706
27707 wxPyEndAllowThreads(__tstate);
27708 if (PyErr_Occurred()) SWIG_fail;
27709 }
27710 Py_INCREF(Py_None); resultobj = Py_None;
27711 return resultobj;
27712 fail:
27713 return NULL;
27714 }
27715
27716
27717 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27718 PyObject *resultobj;
27719 wxWindow *arg1 = (wxWindow *) 0 ;
27720 int result;
27721 PyObject * obj0 = 0 ;
27722 char *kwnames[] = {
27723 (char *) "self", NULL
27724 };
27725
27726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27728 if (SWIG_arg_fail(1)) SWIG_fail;
27729 {
27730 PyThreadState* __tstate = wxPyBeginAllowThreads();
27731 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27732
27733 wxPyEndAllowThreads(__tstate);
27734 if (PyErr_Occurred()) SWIG_fail;
27735 }
27736 {
27737 resultobj = SWIG_From_int((int)(result));
27738 }
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27746 PyObject *resultobj;
27747 wxWindow *arg1 = (wxWindow *) 0 ;
27748 int result;
27749 PyObject * obj0 = 0 ;
27750 char *kwnames[] = {
27751 (char *) "self", NULL
27752 };
27753
27754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27756 if (SWIG_arg_fail(1)) SWIG_fail;
27757 {
27758 PyThreadState* __tstate = wxPyBeginAllowThreads();
27759 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27760
27761 wxPyEndAllowThreads(__tstate);
27762 if (PyErr_Occurred()) SWIG_fail;
27763 }
27764 {
27765 resultobj = SWIG_From_int((int)(result));
27766 }
27767 return resultobj;
27768 fail:
27769 return NULL;
27770 }
27771
27772
27773 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27774 PyObject *resultobj;
27775 wxWindow *arg1 = (wxWindow *) 0 ;
27776 int result;
27777 PyObject * obj0 = 0 ;
27778 char *kwnames[] = {
27779 (char *) "self", NULL
27780 };
27781
27782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27784 if (SWIG_arg_fail(1)) SWIG_fail;
27785 {
27786 PyThreadState* __tstate = wxPyBeginAllowThreads();
27787 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27788
27789 wxPyEndAllowThreads(__tstate);
27790 if (PyErr_Occurred()) SWIG_fail;
27791 }
27792 {
27793 resultobj = SWIG_From_int((int)(result));
27794 }
27795 return resultobj;
27796 fail:
27797 return NULL;
27798 }
27799
27800
27801 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27802 PyObject *resultobj;
27803 wxWindow *arg1 = (wxWindow *) 0 ;
27804 int result;
27805 PyObject * obj0 = 0 ;
27806 char *kwnames[] = {
27807 (char *) "self", NULL
27808 };
27809
27810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27812 if (SWIG_arg_fail(1)) SWIG_fail;
27813 {
27814 PyThreadState* __tstate = wxPyBeginAllowThreads();
27815 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27816
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 {
27821 resultobj = SWIG_From_int((int)(result));
27822 }
27823 return resultobj;
27824 fail:
27825 return NULL;
27826 }
27827
27828
27829 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27830 PyObject *resultobj;
27831 wxWindow *arg1 = (wxWindow *) 0 ;
27832 wxSize *arg2 = 0 ;
27833 wxSize temp2 ;
27834 PyObject * obj0 = 0 ;
27835 PyObject * obj1 = 0 ;
27836 char *kwnames[] = {
27837 (char *) "self",(char *) "size", NULL
27838 };
27839
27840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27842 if (SWIG_arg_fail(1)) SWIG_fail;
27843 {
27844 arg2 = &temp2;
27845 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27846 }
27847 {
27848 PyThreadState* __tstate = wxPyBeginAllowThreads();
27849 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27850
27851 wxPyEndAllowThreads(__tstate);
27852 if (PyErr_Occurred()) SWIG_fail;
27853 }
27854 Py_INCREF(Py_None); resultobj = Py_None;
27855 return resultobj;
27856 fail:
27857 return NULL;
27858 }
27859
27860
27861 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27862 PyObject *resultobj;
27863 wxWindow *arg1 = (wxWindow *) 0 ;
27864 int arg2 ;
27865 int arg3 ;
27866 PyObject * obj0 = 0 ;
27867 PyObject * obj1 = 0 ;
27868 PyObject * obj2 = 0 ;
27869 char *kwnames[] = {
27870 (char *) "self",(char *) "w",(char *) "h", NULL
27871 };
27872
27873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27875 if (SWIG_arg_fail(1)) SWIG_fail;
27876 {
27877 arg2 = (int)(SWIG_As_int(obj1));
27878 if (SWIG_arg_fail(2)) SWIG_fail;
27879 }
27880 {
27881 arg3 = (int)(SWIG_As_int(obj2));
27882 if (SWIG_arg_fail(3)) SWIG_fail;
27883 }
27884 {
27885 PyThreadState* __tstate = wxPyBeginAllowThreads();
27886 (arg1)->SetVirtualSize(arg2,arg3);
27887
27888 wxPyEndAllowThreads(__tstate);
27889 if (PyErr_Occurred()) SWIG_fail;
27890 }
27891 Py_INCREF(Py_None); resultobj = Py_None;
27892 return resultobj;
27893 fail:
27894 return NULL;
27895 }
27896
27897
27898 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27899 PyObject *resultobj;
27900 wxWindow *arg1 = (wxWindow *) 0 ;
27901 wxSize result;
27902 PyObject * obj0 = 0 ;
27903 char *kwnames[] = {
27904 (char *) "self", NULL
27905 };
27906
27907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27909 if (SWIG_arg_fail(1)) SWIG_fail;
27910 {
27911 PyThreadState* __tstate = wxPyBeginAllowThreads();
27912 result = ((wxWindow const *)arg1)->GetVirtualSize();
27913
27914 wxPyEndAllowThreads(__tstate);
27915 if (PyErr_Occurred()) SWIG_fail;
27916 }
27917 {
27918 wxSize * resultptr;
27919 resultptr = new wxSize((wxSize &)(result));
27920 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27921 }
27922 return resultobj;
27923 fail:
27924 return NULL;
27925 }
27926
27927
27928 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27929 PyObject *resultobj;
27930 wxWindow *arg1 = (wxWindow *) 0 ;
27931 int *arg2 = (int *) 0 ;
27932 int *arg3 = (int *) 0 ;
27933 int temp2 ;
27934 int res2 = 0 ;
27935 int temp3 ;
27936 int res3 = 0 ;
27937 PyObject * obj0 = 0 ;
27938 char *kwnames[] = {
27939 (char *) "self", NULL
27940 };
27941
27942 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27943 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27946 if (SWIG_arg_fail(1)) SWIG_fail;
27947 {
27948 PyThreadState* __tstate = wxPyBeginAllowThreads();
27949 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27950
27951 wxPyEndAllowThreads(__tstate);
27952 if (PyErr_Occurred()) SWIG_fail;
27953 }
27954 Py_INCREF(Py_None); resultobj = Py_None;
27955 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27956 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27957 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27958 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj;
27967 wxWindow *arg1 = (wxWindow *) 0 ;
27968 wxSize result;
27969 PyObject * obj0 = 0 ;
27970 char *kwnames[] = {
27971 (char *) "self", NULL
27972 };
27973
27974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27976 if (SWIG_arg_fail(1)) SWIG_fail;
27977 {
27978 PyThreadState* __tstate = wxPyBeginAllowThreads();
27979 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27980
27981 wxPyEndAllowThreads(__tstate);
27982 if (PyErr_Occurred()) SWIG_fail;
27983 }
27984 {
27985 wxSize * resultptr;
27986 resultptr = new wxSize((wxSize &)(result));
27987 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27988 }
27989 return resultobj;
27990 fail:
27991 return NULL;
27992 }
27993
27994
27995 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27996 PyObject *resultobj;
27997 wxWindow *arg1 = (wxWindow *) 0 ;
27998 bool arg2 = (bool) true ;
27999 bool result;
28000 PyObject * obj0 = 0 ;
28001 PyObject * obj1 = 0 ;
28002 char *kwnames[] = {
28003 (char *) "self",(char *) "show", NULL
28004 };
28005
28006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
28007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28008 if (SWIG_arg_fail(1)) SWIG_fail;
28009 if (obj1) {
28010 {
28011 arg2 = (bool)(SWIG_As_bool(obj1));
28012 if (SWIG_arg_fail(2)) SWIG_fail;
28013 }
28014 }
28015 {
28016 PyThreadState* __tstate = wxPyBeginAllowThreads();
28017 result = (bool)(arg1)->Show(arg2);
28018
28019 wxPyEndAllowThreads(__tstate);
28020 if (PyErr_Occurred()) SWIG_fail;
28021 }
28022 {
28023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28024 }
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
28032 PyObject *resultobj;
28033 wxWindow *arg1 = (wxWindow *) 0 ;
28034 bool result;
28035 PyObject * obj0 = 0 ;
28036 char *kwnames[] = {
28037 (char *) "self", NULL
28038 };
28039
28040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
28041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28042 if (SWIG_arg_fail(1)) SWIG_fail;
28043 {
28044 PyThreadState* __tstate = wxPyBeginAllowThreads();
28045 result = (bool)(arg1)->Hide();
28046
28047 wxPyEndAllowThreads(__tstate);
28048 if (PyErr_Occurred()) SWIG_fail;
28049 }
28050 {
28051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28052 }
28053 return resultobj;
28054 fail:
28055 return NULL;
28056 }
28057
28058
28059 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
28060 PyObject *resultobj;
28061 wxWindow *arg1 = (wxWindow *) 0 ;
28062 bool arg2 = (bool) true ;
28063 bool result;
28064 PyObject * obj0 = 0 ;
28065 PyObject * obj1 = 0 ;
28066 char *kwnames[] = {
28067 (char *) "self",(char *) "enable", NULL
28068 };
28069
28070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
28071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28072 if (SWIG_arg_fail(1)) SWIG_fail;
28073 if (obj1) {
28074 {
28075 arg2 = (bool)(SWIG_As_bool(obj1));
28076 if (SWIG_arg_fail(2)) SWIG_fail;
28077 }
28078 }
28079 {
28080 PyThreadState* __tstate = wxPyBeginAllowThreads();
28081 result = (bool)(arg1)->Enable(arg2);
28082
28083 wxPyEndAllowThreads(__tstate);
28084 if (PyErr_Occurred()) SWIG_fail;
28085 }
28086 {
28087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28088 }
28089 return resultobj;
28090 fail:
28091 return NULL;
28092 }
28093
28094
28095 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28096 PyObject *resultobj;
28097 wxWindow *arg1 = (wxWindow *) 0 ;
28098 bool result;
28099 PyObject * obj0 = 0 ;
28100 char *kwnames[] = {
28101 (char *) "self", NULL
28102 };
28103
28104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
28105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28106 if (SWIG_arg_fail(1)) SWIG_fail;
28107 {
28108 PyThreadState* __tstate = wxPyBeginAllowThreads();
28109 result = (bool)(arg1)->Disable();
28110
28111 wxPyEndAllowThreads(__tstate);
28112 if (PyErr_Occurred()) SWIG_fail;
28113 }
28114 {
28115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28116 }
28117 return resultobj;
28118 fail:
28119 return NULL;
28120 }
28121
28122
28123 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28124 PyObject *resultobj;
28125 wxWindow *arg1 = (wxWindow *) 0 ;
28126 bool result;
28127 PyObject * obj0 = 0 ;
28128 char *kwnames[] = {
28129 (char *) "self", NULL
28130 };
28131
28132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28134 if (SWIG_arg_fail(1)) SWIG_fail;
28135 {
28136 PyThreadState* __tstate = wxPyBeginAllowThreads();
28137 result = (bool)((wxWindow const *)arg1)->IsShown();
28138
28139 wxPyEndAllowThreads(__tstate);
28140 if (PyErr_Occurred()) SWIG_fail;
28141 }
28142 {
28143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28144 }
28145 return resultobj;
28146 fail:
28147 return NULL;
28148 }
28149
28150
28151 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28152 PyObject *resultobj;
28153 wxWindow *arg1 = (wxWindow *) 0 ;
28154 bool result;
28155 PyObject * obj0 = 0 ;
28156 char *kwnames[] = {
28157 (char *) "self", NULL
28158 };
28159
28160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28162 if (SWIG_arg_fail(1)) SWIG_fail;
28163 {
28164 PyThreadState* __tstate = wxPyBeginAllowThreads();
28165 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28166
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 {
28171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28172 }
28173 return resultobj;
28174 fail:
28175 return NULL;
28176 }
28177
28178
28179 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28180 PyObject *resultobj;
28181 wxWindow *arg1 = (wxWindow *) 0 ;
28182 long arg2 ;
28183 PyObject * obj0 = 0 ;
28184 PyObject * obj1 = 0 ;
28185 char *kwnames[] = {
28186 (char *) "self",(char *) "style", NULL
28187 };
28188
28189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28191 if (SWIG_arg_fail(1)) SWIG_fail;
28192 {
28193 arg2 = (long)(SWIG_As_long(obj1));
28194 if (SWIG_arg_fail(2)) SWIG_fail;
28195 }
28196 {
28197 PyThreadState* __tstate = wxPyBeginAllowThreads();
28198 (arg1)->SetWindowStyleFlag(arg2);
28199
28200 wxPyEndAllowThreads(__tstate);
28201 if (PyErr_Occurred()) SWIG_fail;
28202 }
28203 Py_INCREF(Py_None); resultobj = Py_None;
28204 return resultobj;
28205 fail:
28206 return NULL;
28207 }
28208
28209
28210 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28211 PyObject *resultobj;
28212 wxWindow *arg1 = (wxWindow *) 0 ;
28213 long result;
28214 PyObject * obj0 = 0 ;
28215 char *kwnames[] = {
28216 (char *) "self", NULL
28217 };
28218
28219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28221 if (SWIG_arg_fail(1)) SWIG_fail;
28222 {
28223 PyThreadState* __tstate = wxPyBeginAllowThreads();
28224 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28225
28226 wxPyEndAllowThreads(__tstate);
28227 if (PyErr_Occurred()) SWIG_fail;
28228 }
28229 {
28230 resultobj = SWIG_From_long((long)(result));
28231 }
28232 return resultobj;
28233 fail:
28234 return NULL;
28235 }
28236
28237
28238 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28239 PyObject *resultobj;
28240 wxWindow *arg1 = (wxWindow *) 0 ;
28241 int arg2 ;
28242 bool result;
28243 PyObject * obj0 = 0 ;
28244 PyObject * obj1 = 0 ;
28245 char *kwnames[] = {
28246 (char *) "self",(char *) "flag", NULL
28247 };
28248
28249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28251 if (SWIG_arg_fail(1)) SWIG_fail;
28252 {
28253 arg2 = (int)(SWIG_As_int(obj1));
28254 if (SWIG_arg_fail(2)) SWIG_fail;
28255 }
28256 {
28257 PyThreadState* __tstate = wxPyBeginAllowThreads();
28258 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28259
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 {
28264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28265 }
28266 return resultobj;
28267 fail:
28268 return NULL;
28269 }
28270
28271
28272 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28273 PyObject *resultobj;
28274 wxWindow *arg1 = (wxWindow *) 0 ;
28275 bool result;
28276 PyObject * obj0 = 0 ;
28277 char *kwnames[] = {
28278 (char *) "self", NULL
28279 };
28280
28281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28283 if (SWIG_arg_fail(1)) SWIG_fail;
28284 {
28285 PyThreadState* __tstate = wxPyBeginAllowThreads();
28286 result = (bool)((wxWindow const *)arg1)->IsRetained();
28287
28288 wxPyEndAllowThreads(__tstate);
28289 if (PyErr_Occurred()) SWIG_fail;
28290 }
28291 {
28292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28293 }
28294 return resultobj;
28295 fail:
28296 return NULL;
28297 }
28298
28299
28300 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28301 PyObject *resultobj;
28302 wxWindow *arg1 = (wxWindow *) 0 ;
28303 long arg2 ;
28304 PyObject * obj0 = 0 ;
28305 PyObject * obj1 = 0 ;
28306 char *kwnames[] = {
28307 (char *) "self",(char *) "exStyle", NULL
28308 };
28309
28310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28312 if (SWIG_arg_fail(1)) SWIG_fail;
28313 {
28314 arg2 = (long)(SWIG_As_long(obj1));
28315 if (SWIG_arg_fail(2)) SWIG_fail;
28316 }
28317 {
28318 PyThreadState* __tstate = wxPyBeginAllowThreads();
28319 (arg1)->SetExtraStyle(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_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28332 PyObject *resultobj;
28333 wxWindow *arg1 = (wxWindow *) 0 ;
28334 long result;
28335 PyObject * obj0 = 0 ;
28336 char *kwnames[] = {
28337 (char *) "self", NULL
28338 };
28339
28340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28342 if (SWIG_arg_fail(1)) SWIG_fail;
28343 {
28344 PyThreadState* __tstate = wxPyBeginAllowThreads();
28345 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28346
28347 wxPyEndAllowThreads(__tstate);
28348 if (PyErr_Occurred()) SWIG_fail;
28349 }
28350 {
28351 resultobj = SWIG_From_long((long)(result));
28352 }
28353 return resultobj;
28354 fail:
28355 return NULL;
28356 }
28357
28358
28359 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28360 PyObject *resultobj;
28361 wxWindow *arg1 = (wxWindow *) 0 ;
28362 bool arg2 = (bool) true ;
28363 PyObject * obj0 = 0 ;
28364 PyObject * obj1 = 0 ;
28365 char *kwnames[] = {
28366 (char *) "self",(char *) "modal", NULL
28367 };
28368
28369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28371 if (SWIG_arg_fail(1)) SWIG_fail;
28372 if (obj1) {
28373 {
28374 arg2 = (bool)(SWIG_As_bool(obj1));
28375 if (SWIG_arg_fail(2)) SWIG_fail;
28376 }
28377 }
28378 {
28379 PyThreadState* __tstate = wxPyBeginAllowThreads();
28380 (arg1)->MakeModal(arg2);
28381
28382 wxPyEndAllowThreads(__tstate);
28383 if (PyErr_Occurred()) SWIG_fail;
28384 }
28385 Py_INCREF(Py_None); resultobj = Py_None;
28386 return resultobj;
28387 fail:
28388 return NULL;
28389 }
28390
28391
28392 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28393 PyObject *resultobj;
28394 wxWindow *arg1 = (wxWindow *) 0 ;
28395 bool arg2 ;
28396 PyObject * obj0 = 0 ;
28397 PyObject * obj1 = 0 ;
28398 char *kwnames[] = {
28399 (char *) "self",(char *) "enableTheme", NULL
28400 };
28401
28402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28404 if (SWIG_arg_fail(1)) SWIG_fail;
28405 {
28406 arg2 = (bool)(SWIG_As_bool(obj1));
28407 if (SWIG_arg_fail(2)) SWIG_fail;
28408 }
28409 {
28410 PyThreadState* __tstate = wxPyBeginAllowThreads();
28411 (arg1)->SetThemeEnabled(arg2);
28412
28413 wxPyEndAllowThreads(__tstate);
28414 if (PyErr_Occurred()) SWIG_fail;
28415 }
28416 Py_INCREF(Py_None); resultobj = Py_None;
28417 return resultobj;
28418 fail:
28419 return NULL;
28420 }
28421
28422
28423 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28424 PyObject *resultobj;
28425 wxWindow *arg1 = (wxWindow *) 0 ;
28426 bool result;
28427 PyObject * obj0 = 0 ;
28428 char *kwnames[] = {
28429 (char *) "self", NULL
28430 };
28431
28432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28434 if (SWIG_arg_fail(1)) SWIG_fail;
28435 {
28436 PyThreadState* __tstate = wxPyBeginAllowThreads();
28437 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28438
28439 wxPyEndAllowThreads(__tstate);
28440 if (PyErr_Occurred()) SWIG_fail;
28441 }
28442 {
28443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28444 }
28445 return resultobj;
28446 fail:
28447 return NULL;
28448 }
28449
28450
28451 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28452 PyObject *resultobj;
28453 wxWindow *arg1 = (wxWindow *) 0 ;
28454 PyObject * obj0 = 0 ;
28455 char *kwnames[] = {
28456 (char *) "self", NULL
28457 };
28458
28459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
28460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28461 if (SWIG_arg_fail(1)) SWIG_fail;
28462 {
28463 PyThreadState* __tstate = wxPyBeginAllowThreads();
28464 (arg1)->SetFocus();
28465
28466 wxPyEndAllowThreads(__tstate);
28467 if (PyErr_Occurred()) SWIG_fail;
28468 }
28469 Py_INCREF(Py_None); resultobj = Py_None;
28470 return resultobj;
28471 fail:
28472 return NULL;
28473 }
28474
28475
28476 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28477 PyObject *resultobj;
28478 wxWindow *arg1 = (wxWindow *) 0 ;
28479 PyObject * obj0 = 0 ;
28480 char *kwnames[] = {
28481 (char *) "self", NULL
28482 };
28483
28484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28486 if (SWIG_arg_fail(1)) SWIG_fail;
28487 {
28488 PyThreadState* __tstate = wxPyBeginAllowThreads();
28489 (arg1)->SetFocusFromKbd();
28490
28491 wxPyEndAllowThreads(__tstate);
28492 if (PyErr_Occurred()) SWIG_fail;
28493 }
28494 Py_INCREF(Py_None); resultobj = Py_None;
28495 return resultobj;
28496 fail:
28497 return NULL;
28498 }
28499
28500
28501 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28502 PyObject *resultobj;
28503 wxWindow *result;
28504 char *kwnames[] = {
28505 NULL
28506 };
28507
28508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28509 {
28510 if (!wxPyCheckForApp()) SWIG_fail;
28511 PyThreadState* __tstate = wxPyBeginAllowThreads();
28512 result = (wxWindow *)wxWindow::FindFocus();
28513
28514 wxPyEndAllowThreads(__tstate);
28515 if (PyErr_Occurred()) SWIG_fail;
28516 }
28517 {
28518 resultobj = wxPyMake_wxObject(result, 0);
28519 }
28520 return resultobj;
28521 fail:
28522 return NULL;
28523 }
28524
28525
28526 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28527 PyObject *resultobj;
28528 wxWindow *arg1 = (wxWindow *) 0 ;
28529 bool result;
28530 PyObject * obj0 = 0 ;
28531 char *kwnames[] = {
28532 (char *) "self", NULL
28533 };
28534
28535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28537 if (SWIG_arg_fail(1)) SWIG_fail;
28538 {
28539 PyThreadState* __tstate = wxPyBeginAllowThreads();
28540 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28541
28542 wxPyEndAllowThreads(__tstate);
28543 if (PyErr_Occurred()) SWIG_fail;
28544 }
28545 {
28546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28547 }
28548 return resultobj;
28549 fail:
28550 return NULL;
28551 }
28552
28553
28554 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28555 PyObject *resultobj;
28556 wxWindow *arg1 = (wxWindow *) 0 ;
28557 bool result;
28558 PyObject * obj0 = 0 ;
28559 char *kwnames[] = {
28560 (char *) "self", NULL
28561 };
28562
28563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28565 if (SWIG_arg_fail(1)) SWIG_fail;
28566 {
28567 PyThreadState* __tstate = wxPyBeginAllowThreads();
28568 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28569
28570 wxPyEndAllowThreads(__tstate);
28571 if (PyErr_Occurred()) SWIG_fail;
28572 }
28573 {
28574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28575 }
28576 return resultobj;
28577 fail:
28578 return NULL;
28579 }
28580
28581
28582 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28583 PyObject *resultobj;
28584 wxWindow *arg1 = (wxWindow *) 0 ;
28585 wxWindow *result;
28586 PyObject * obj0 = 0 ;
28587 char *kwnames[] = {
28588 (char *) "self", NULL
28589 };
28590
28591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28593 if (SWIG_arg_fail(1)) SWIG_fail;
28594 {
28595 PyThreadState* __tstate = wxPyBeginAllowThreads();
28596 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28597
28598 wxPyEndAllowThreads(__tstate);
28599 if (PyErr_Occurred()) SWIG_fail;
28600 }
28601 {
28602 resultobj = wxPyMake_wxObject(result, 0);
28603 }
28604 return resultobj;
28605 fail:
28606 return NULL;
28607 }
28608
28609
28610 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28611 PyObject *resultobj;
28612 wxWindow *arg1 = (wxWindow *) 0 ;
28613 wxWindow *arg2 = (wxWindow *) 0 ;
28614 wxWindow *result;
28615 PyObject * obj0 = 0 ;
28616 PyObject * obj1 = 0 ;
28617 char *kwnames[] = {
28618 (char *) "self",(char *) "child", NULL
28619 };
28620
28621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28623 if (SWIG_arg_fail(1)) SWIG_fail;
28624 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28625 if (SWIG_arg_fail(2)) SWIG_fail;
28626 {
28627 PyThreadState* __tstate = wxPyBeginAllowThreads();
28628 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28629
28630 wxPyEndAllowThreads(__tstate);
28631 if (PyErr_Occurred()) SWIG_fail;
28632 }
28633 {
28634 resultobj = wxPyMake_wxObject(result, 0);
28635 }
28636 return resultobj;
28637 fail:
28638 return NULL;
28639 }
28640
28641
28642 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28643 PyObject *resultobj;
28644 wxWindow *arg1 = (wxWindow *) 0 ;
28645 wxWindow *arg2 = (wxWindow *) 0 ;
28646 PyObject * obj0 = 0 ;
28647 PyObject * obj1 = 0 ;
28648 char *kwnames[] = {
28649 (char *) "self",(char *) "win", NULL
28650 };
28651
28652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28654 if (SWIG_arg_fail(1)) SWIG_fail;
28655 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28656 if (SWIG_arg_fail(2)) SWIG_fail;
28657 {
28658 PyThreadState* __tstate = wxPyBeginAllowThreads();
28659 (arg1)->SetTmpDefaultItem(arg2);
28660
28661 wxPyEndAllowThreads(__tstate);
28662 if (PyErr_Occurred()) SWIG_fail;
28663 }
28664 Py_INCREF(Py_None); resultobj = Py_None;
28665 return resultobj;
28666 fail:
28667 return NULL;
28668 }
28669
28670
28671 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28672 PyObject *resultobj;
28673 wxWindow *arg1 = (wxWindow *) 0 ;
28674 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28675 bool result;
28676 PyObject * obj0 = 0 ;
28677 PyObject * obj1 = 0 ;
28678 char *kwnames[] = {
28679 (char *) "self",(char *) "flags", NULL
28680 };
28681
28682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28684 if (SWIG_arg_fail(1)) SWIG_fail;
28685 if (obj1) {
28686 {
28687 arg2 = (int)(SWIG_As_int(obj1));
28688 if (SWIG_arg_fail(2)) SWIG_fail;
28689 }
28690 }
28691 {
28692 PyThreadState* __tstate = wxPyBeginAllowThreads();
28693 result = (bool)(arg1)->Navigate(arg2);
28694
28695 wxPyEndAllowThreads(__tstate);
28696 if (PyErr_Occurred()) SWIG_fail;
28697 }
28698 {
28699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28700 }
28701 return resultobj;
28702 fail:
28703 return NULL;
28704 }
28705
28706
28707 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28708 PyObject *resultobj;
28709 wxWindow *arg1 = (wxWindow *) 0 ;
28710 wxWindow *arg2 = (wxWindow *) 0 ;
28711 PyObject * obj0 = 0 ;
28712 PyObject * obj1 = 0 ;
28713 char *kwnames[] = {
28714 (char *) "self",(char *) "win", NULL
28715 };
28716
28717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28719 if (SWIG_arg_fail(1)) SWIG_fail;
28720 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28721 if (SWIG_arg_fail(2)) SWIG_fail;
28722 {
28723 PyThreadState* __tstate = wxPyBeginAllowThreads();
28724 (arg1)->MoveAfterInTabOrder(arg2);
28725
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 Py_INCREF(Py_None); resultobj = Py_None;
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28737 PyObject *resultobj;
28738 wxWindow *arg1 = (wxWindow *) 0 ;
28739 wxWindow *arg2 = (wxWindow *) 0 ;
28740 PyObject * obj0 = 0 ;
28741 PyObject * obj1 = 0 ;
28742 char *kwnames[] = {
28743 (char *) "self",(char *) "win", NULL
28744 };
28745
28746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28748 if (SWIG_arg_fail(1)) SWIG_fail;
28749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28750 if (SWIG_arg_fail(2)) SWIG_fail;
28751 {
28752 PyThreadState* __tstate = wxPyBeginAllowThreads();
28753 (arg1)->MoveBeforeInTabOrder(arg2);
28754
28755 wxPyEndAllowThreads(__tstate);
28756 if (PyErr_Occurred()) SWIG_fail;
28757 }
28758 Py_INCREF(Py_None); resultobj = Py_None;
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28766 PyObject *resultobj;
28767 wxWindow *arg1 = (wxWindow *) 0 ;
28768 PyObject *result;
28769 PyObject * obj0 = 0 ;
28770 char *kwnames[] = {
28771 (char *) "self", NULL
28772 };
28773
28774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28776 if (SWIG_arg_fail(1)) SWIG_fail;
28777 {
28778 PyThreadState* __tstate = wxPyBeginAllowThreads();
28779 result = (PyObject *)wxWindow_GetChildren(arg1);
28780
28781 wxPyEndAllowThreads(__tstate);
28782 if (PyErr_Occurred()) SWIG_fail;
28783 }
28784 resultobj = result;
28785 return resultobj;
28786 fail:
28787 return NULL;
28788 }
28789
28790
28791 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28792 PyObject *resultobj;
28793 wxWindow *arg1 = (wxWindow *) 0 ;
28794 wxWindow *result;
28795 PyObject * obj0 = 0 ;
28796 char *kwnames[] = {
28797 (char *) "self", NULL
28798 };
28799
28800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28802 if (SWIG_arg_fail(1)) SWIG_fail;
28803 {
28804 PyThreadState* __tstate = wxPyBeginAllowThreads();
28805 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28806
28807 wxPyEndAllowThreads(__tstate);
28808 if (PyErr_Occurred()) SWIG_fail;
28809 }
28810 {
28811 resultobj = wxPyMake_wxObject(result, 0);
28812 }
28813 return resultobj;
28814 fail:
28815 return NULL;
28816 }
28817
28818
28819 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28820 PyObject *resultobj;
28821 wxWindow *arg1 = (wxWindow *) 0 ;
28822 wxWindow *result;
28823 PyObject * obj0 = 0 ;
28824 char *kwnames[] = {
28825 (char *) "self", NULL
28826 };
28827
28828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28830 if (SWIG_arg_fail(1)) SWIG_fail;
28831 {
28832 PyThreadState* __tstate = wxPyBeginAllowThreads();
28833 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28834
28835 wxPyEndAllowThreads(__tstate);
28836 if (PyErr_Occurred()) SWIG_fail;
28837 }
28838 {
28839 resultobj = wxPyMake_wxObject(result, 0);
28840 }
28841 return resultobj;
28842 fail:
28843 return NULL;
28844 }
28845
28846
28847 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28848 PyObject *resultobj;
28849 wxWindow *arg1 = (wxWindow *) 0 ;
28850 bool result;
28851 PyObject * obj0 = 0 ;
28852 char *kwnames[] = {
28853 (char *) "self", NULL
28854 };
28855
28856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28858 if (SWIG_arg_fail(1)) SWIG_fail;
28859 {
28860 PyThreadState* __tstate = wxPyBeginAllowThreads();
28861 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28862
28863 wxPyEndAllowThreads(__tstate);
28864 if (PyErr_Occurred()) SWIG_fail;
28865 }
28866 {
28867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28868 }
28869 return resultobj;
28870 fail:
28871 return NULL;
28872 }
28873
28874
28875 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28876 PyObject *resultobj;
28877 wxWindow *arg1 = (wxWindow *) 0 ;
28878 wxWindow *arg2 = (wxWindow *) 0 ;
28879 bool result;
28880 PyObject * obj0 = 0 ;
28881 PyObject * obj1 = 0 ;
28882 char *kwnames[] = {
28883 (char *) "self",(char *) "newParent", NULL
28884 };
28885
28886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28888 if (SWIG_arg_fail(1)) SWIG_fail;
28889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28890 if (SWIG_arg_fail(2)) SWIG_fail;
28891 {
28892 PyThreadState* __tstate = wxPyBeginAllowThreads();
28893 result = (bool)(arg1)->Reparent(arg2);
28894
28895 wxPyEndAllowThreads(__tstate);
28896 if (PyErr_Occurred()) SWIG_fail;
28897 }
28898 {
28899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28900 }
28901 return resultobj;
28902 fail:
28903 return NULL;
28904 }
28905
28906
28907 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28908 PyObject *resultobj;
28909 wxWindow *arg1 = (wxWindow *) 0 ;
28910 wxWindow *arg2 = (wxWindow *) 0 ;
28911 PyObject * obj0 = 0 ;
28912 PyObject * obj1 = 0 ;
28913 char *kwnames[] = {
28914 (char *) "self",(char *) "child", NULL
28915 };
28916
28917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28919 if (SWIG_arg_fail(1)) SWIG_fail;
28920 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28921 if (SWIG_arg_fail(2)) SWIG_fail;
28922 {
28923 PyThreadState* __tstate = wxPyBeginAllowThreads();
28924 (arg1)->AddChild(arg2);
28925
28926 wxPyEndAllowThreads(__tstate);
28927 if (PyErr_Occurred()) SWIG_fail;
28928 }
28929 Py_INCREF(Py_None); resultobj = Py_None;
28930 return resultobj;
28931 fail:
28932 return NULL;
28933 }
28934
28935
28936 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28937 PyObject *resultobj;
28938 wxWindow *arg1 = (wxWindow *) 0 ;
28939 wxWindow *arg2 = (wxWindow *) 0 ;
28940 PyObject * obj0 = 0 ;
28941 PyObject * obj1 = 0 ;
28942 char *kwnames[] = {
28943 (char *) "self",(char *) "child", NULL
28944 };
28945
28946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28948 if (SWIG_arg_fail(1)) SWIG_fail;
28949 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28950 if (SWIG_arg_fail(2)) SWIG_fail;
28951 {
28952 PyThreadState* __tstate = wxPyBeginAllowThreads();
28953 (arg1)->RemoveChild(arg2);
28954
28955 wxPyEndAllowThreads(__tstate);
28956 if (PyErr_Occurred()) SWIG_fail;
28957 }
28958 Py_INCREF(Py_None); resultobj = Py_None;
28959 return resultobj;
28960 fail:
28961 return NULL;
28962 }
28963
28964
28965 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28966 PyObject *resultobj;
28967 wxWindow *arg1 = (wxWindow *) 0 ;
28968 long arg2 ;
28969 wxWindow *result;
28970 PyObject * obj0 = 0 ;
28971 PyObject * obj1 = 0 ;
28972 char *kwnames[] = {
28973 (char *) "self",(char *) "winid", NULL
28974 };
28975
28976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28978 if (SWIG_arg_fail(1)) SWIG_fail;
28979 {
28980 arg2 = (long)(SWIG_As_long(obj1));
28981 if (SWIG_arg_fail(2)) SWIG_fail;
28982 }
28983 {
28984 PyThreadState* __tstate = wxPyBeginAllowThreads();
28985 result = (wxWindow *)(arg1)->FindWindow(arg2);
28986
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 {
28991 resultobj = wxPyMake_wxObject(result, 0);
28992 }
28993 return resultobj;
28994 fail:
28995 return NULL;
28996 }
28997
28998
28999 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
29000 PyObject *resultobj;
29001 wxWindow *arg1 = (wxWindow *) 0 ;
29002 wxString *arg2 = 0 ;
29003 wxWindow *result;
29004 bool temp2 = false ;
29005 PyObject * obj0 = 0 ;
29006 PyObject * obj1 = 0 ;
29007 char *kwnames[] = {
29008 (char *) "self",(char *) "name", NULL
29009 };
29010
29011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
29012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29013 if (SWIG_arg_fail(1)) SWIG_fail;
29014 {
29015 arg2 = wxString_in_helper(obj1);
29016 if (arg2 == NULL) SWIG_fail;
29017 temp2 = true;
29018 }
29019 {
29020 PyThreadState* __tstate = wxPyBeginAllowThreads();
29021 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
29022
29023 wxPyEndAllowThreads(__tstate);
29024 if (PyErr_Occurred()) SWIG_fail;
29025 }
29026 {
29027 resultobj = wxPyMake_wxObject(result, 0);
29028 }
29029 {
29030 if (temp2)
29031 delete arg2;
29032 }
29033 return resultobj;
29034 fail:
29035 {
29036 if (temp2)
29037 delete arg2;
29038 }
29039 return NULL;
29040 }
29041
29042
29043 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29044 PyObject *resultobj;
29045 wxWindow *arg1 = (wxWindow *) 0 ;
29046 wxEvtHandler *result;
29047 PyObject * obj0 = 0 ;
29048 char *kwnames[] = {
29049 (char *) "self", NULL
29050 };
29051
29052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
29053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29054 if (SWIG_arg_fail(1)) SWIG_fail;
29055 {
29056 PyThreadState* __tstate = wxPyBeginAllowThreads();
29057 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
29058
29059 wxPyEndAllowThreads(__tstate);
29060 if (PyErr_Occurred()) SWIG_fail;
29061 }
29062 {
29063 resultobj = wxPyMake_wxObject(result, 0);
29064 }
29065 return resultobj;
29066 fail:
29067 return NULL;
29068 }
29069
29070
29071 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29072 PyObject *resultobj;
29073 wxWindow *arg1 = (wxWindow *) 0 ;
29074 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29075 PyObject * obj0 = 0 ;
29076 PyObject * obj1 = 0 ;
29077 char *kwnames[] = {
29078 (char *) "self",(char *) "handler", NULL
29079 };
29080
29081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
29082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29083 if (SWIG_arg_fail(1)) SWIG_fail;
29084 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29085 if (SWIG_arg_fail(2)) SWIG_fail;
29086 {
29087 PyThreadState* __tstate = wxPyBeginAllowThreads();
29088 (arg1)->SetEventHandler(arg2);
29089
29090 wxPyEndAllowThreads(__tstate);
29091 if (PyErr_Occurred()) SWIG_fail;
29092 }
29093 Py_INCREF(Py_None); resultobj = Py_None;
29094 return resultobj;
29095 fail:
29096 return NULL;
29097 }
29098
29099
29100 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29101 PyObject *resultobj;
29102 wxWindow *arg1 = (wxWindow *) 0 ;
29103 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29104 PyObject * obj0 = 0 ;
29105 PyObject * obj1 = 0 ;
29106 char *kwnames[] = {
29107 (char *) "self",(char *) "handler", NULL
29108 };
29109
29110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29114 if (SWIG_arg_fail(2)) SWIG_fail;
29115 {
29116 PyThreadState* __tstate = wxPyBeginAllowThreads();
29117 (arg1)->PushEventHandler(arg2);
29118
29119 wxPyEndAllowThreads(__tstate);
29120 if (PyErr_Occurred()) SWIG_fail;
29121 }
29122 Py_INCREF(Py_None); resultobj = Py_None;
29123 return resultobj;
29124 fail:
29125 return NULL;
29126 }
29127
29128
29129 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29130 PyObject *resultobj;
29131 wxWindow *arg1 = (wxWindow *) 0 ;
29132 bool arg2 = (bool) false ;
29133 wxEvtHandler *result;
29134 PyObject * obj0 = 0 ;
29135 PyObject * obj1 = 0 ;
29136 char *kwnames[] = {
29137 (char *) "self",(char *) "deleteHandler", NULL
29138 };
29139
29140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29142 if (SWIG_arg_fail(1)) SWIG_fail;
29143 if (obj1) {
29144 {
29145 arg2 = (bool)(SWIG_As_bool(obj1));
29146 if (SWIG_arg_fail(2)) SWIG_fail;
29147 }
29148 }
29149 {
29150 PyThreadState* __tstate = wxPyBeginAllowThreads();
29151 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29152
29153 wxPyEndAllowThreads(__tstate);
29154 if (PyErr_Occurred()) SWIG_fail;
29155 }
29156 {
29157 resultobj = wxPyMake_wxObject(result, 0);
29158 }
29159 return resultobj;
29160 fail:
29161 return NULL;
29162 }
29163
29164
29165 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29166 PyObject *resultobj;
29167 wxWindow *arg1 = (wxWindow *) 0 ;
29168 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29169 bool result;
29170 PyObject * obj0 = 0 ;
29171 PyObject * obj1 = 0 ;
29172 char *kwnames[] = {
29173 (char *) "self",(char *) "handler", NULL
29174 };
29175
29176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29178 if (SWIG_arg_fail(1)) SWIG_fail;
29179 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29180 if (SWIG_arg_fail(2)) SWIG_fail;
29181 {
29182 PyThreadState* __tstate = wxPyBeginAllowThreads();
29183 result = (bool)(arg1)->RemoveEventHandler(arg2);
29184
29185 wxPyEndAllowThreads(__tstate);
29186 if (PyErr_Occurred()) SWIG_fail;
29187 }
29188 {
29189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29190 }
29191 return resultobj;
29192 fail:
29193 return NULL;
29194 }
29195
29196
29197 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29198 PyObject *resultobj;
29199 wxWindow *arg1 = (wxWindow *) 0 ;
29200 wxValidator *arg2 = 0 ;
29201 PyObject * obj0 = 0 ;
29202 PyObject * obj1 = 0 ;
29203 char *kwnames[] = {
29204 (char *) "self",(char *) "validator", NULL
29205 };
29206
29207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29209 if (SWIG_arg_fail(1)) SWIG_fail;
29210 {
29211 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29212 if (SWIG_arg_fail(2)) SWIG_fail;
29213 if (arg2 == NULL) {
29214 SWIG_null_ref("wxValidator");
29215 }
29216 if (SWIG_arg_fail(2)) SWIG_fail;
29217 }
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 (arg1)->SetValidator((wxValidator const &)*arg2);
29221
29222 wxPyEndAllowThreads(__tstate);
29223 if (PyErr_Occurred()) SWIG_fail;
29224 }
29225 Py_INCREF(Py_None); resultobj = Py_None;
29226 return resultobj;
29227 fail:
29228 return NULL;
29229 }
29230
29231
29232 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29233 PyObject *resultobj;
29234 wxWindow *arg1 = (wxWindow *) 0 ;
29235 wxValidator *result;
29236 PyObject * obj0 = 0 ;
29237 char *kwnames[] = {
29238 (char *) "self", NULL
29239 };
29240
29241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29243 if (SWIG_arg_fail(1)) SWIG_fail;
29244 {
29245 PyThreadState* __tstate = wxPyBeginAllowThreads();
29246 result = (wxValidator *)(arg1)->GetValidator();
29247
29248 wxPyEndAllowThreads(__tstate);
29249 if (PyErr_Occurred()) SWIG_fail;
29250 }
29251 {
29252 resultobj = wxPyMake_wxObject(result, 0);
29253 }
29254 return resultobj;
29255 fail:
29256 return NULL;
29257 }
29258
29259
29260 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29261 PyObject *resultobj;
29262 wxWindow *arg1 = (wxWindow *) 0 ;
29263 bool result;
29264 PyObject * obj0 = 0 ;
29265 char *kwnames[] = {
29266 (char *) "self", NULL
29267 };
29268
29269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29271 if (SWIG_arg_fail(1)) SWIG_fail;
29272 {
29273 PyThreadState* __tstate = wxPyBeginAllowThreads();
29274 result = (bool)(arg1)->Validate();
29275
29276 wxPyEndAllowThreads(__tstate);
29277 if (PyErr_Occurred()) SWIG_fail;
29278 }
29279 {
29280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29281 }
29282 return resultobj;
29283 fail:
29284 return NULL;
29285 }
29286
29287
29288 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29289 PyObject *resultobj;
29290 wxWindow *arg1 = (wxWindow *) 0 ;
29291 bool result;
29292 PyObject * obj0 = 0 ;
29293 char *kwnames[] = {
29294 (char *) "self", NULL
29295 };
29296
29297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29299 if (SWIG_arg_fail(1)) SWIG_fail;
29300 {
29301 PyThreadState* __tstate = wxPyBeginAllowThreads();
29302 result = (bool)(arg1)->TransferDataToWindow();
29303
29304 wxPyEndAllowThreads(__tstate);
29305 if (PyErr_Occurred()) SWIG_fail;
29306 }
29307 {
29308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29309 }
29310 return resultobj;
29311 fail:
29312 return NULL;
29313 }
29314
29315
29316 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29317 PyObject *resultobj;
29318 wxWindow *arg1 = (wxWindow *) 0 ;
29319 bool result;
29320 PyObject * obj0 = 0 ;
29321 char *kwnames[] = {
29322 (char *) "self", NULL
29323 };
29324
29325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",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 result = (bool)(arg1)->TransferDataFromWindow();
29331
29332 wxPyEndAllowThreads(__tstate);
29333 if (PyErr_Occurred()) SWIG_fail;
29334 }
29335 {
29336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29337 }
29338 return resultobj;
29339 fail:
29340 return NULL;
29341 }
29342
29343
29344 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29345 PyObject *resultobj;
29346 wxWindow *arg1 = (wxWindow *) 0 ;
29347 PyObject * obj0 = 0 ;
29348 char *kwnames[] = {
29349 (char *) "self", NULL
29350 };
29351
29352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29354 if (SWIG_arg_fail(1)) SWIG_fail;
29355 {
29356 PyThreadState* __tstate = wxPyBeginAllowThreads();
29357 (arg1)->InitDialog();
29358
29359 wxPyEndAllowThreads(__tstate);
29360 if (PyErr_Occurred()) SWIG_fail;
29361 }
29362 Py_INCREF(Py_None); resultobj = Py_None;
29363 return resultobj;
29364 fail:
29365 return NULL;
29366 }
29367
29368
29369 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29370 PyObject *resultobj;
29371 wxWindow *arg1 = (wxWindow *) 0 ;
29372 wxAcceleratorTable *arg2 = 0 ;
29373 PyObject * obj0 = 0 ;
29374 PyObject * obj1 = 0 ;
29375 char *kwnames[] = {
29376 (char *) "self",(char *) "accel", NULL
29377 };
29378
29379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29381 if (SWIG_arg_fail(1)) SWIG_fail;
29382 {
29383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29384 if (SWIG_arg_fail(2)) SWIG_fail;
29385 if (arg2 == NULL) {
29386 SWIG_null_ref("wxAcceleratorTable");
29387 }
29388 if (SWIG_arg_fail(2)) SWIG_fail;
29389 }
29390 {
29391 PyThreadState* __tstate = wxPyBeginAllowThreads();
29392 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29393
29394 wxPyEndAllowThreads(__tstate);
29395 if (PyErr_Occurred()) SWIG_fail;
29396 }
29397 Py_INCREF(Py_None); resultobj = Py_None;
29398 return resultobj;
29399 fail:
29400 return NULL;
29401 }
29402
29403
29404 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29405 PyObject *resultobj;
29406 wxWindow *arg1 = (wxWindow *) 0 ;
29407 wxAcceleratorTable *result;
29408 PyObject * obj0 = 0 ;
29409 char *kwnames[] = {
29410 (char *) "self", NULL
29411 };
29412
29413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29415 if (SWIG_arg_fail(1)) SWIG_fail;
29416 {
29417 PyThreadState* __tstate = wxPyBeginAllowThreads();
29418 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29419
29420 wxPyEndAllowThreads(__tstate);
29421 if (PyErr_Occurred()) SWIG_fail;
29422 }
29423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29424 return resultobj;
29425 fail:
29426 return NULL;
29427 }
29428
29429
29430 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29431 PyObject *resultobj;
29432 wxWindow *arg1 = (wxWindow *) 0 ;
29433 int arg2 ;
29434 int arg3 ;
29435 int arg4 ;
29436 bool result;
29437 PyObject * obj0 = 0 ;
29438 PyObject * obj1 = 0 ;
29439 PyObject * obj2 = 0 ;
29440 PyObject * obj3 = 0 ;
29441 char *kwnames[] = {
29442 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29443 };
29444
29445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29447 if (SWIG_arg_fail(1)) SWIG_fail;
29448 {
29449 arg2 = (int)(SWIG_As_int(obj1));
29450 if (SWIG_arg_fail(2)) SWIG_fail;
29451 }
29452 {
29453 arg3 = (int)(SWIG_As_int(obj2));
29454 if (SWIG_arg_fail(3)) SWIG_fail;
29455 }
29456 {
29457 arg4 = (int)(SWIG_As_int(obj3));
29458 if (SWIG_arg_fail(4)) SWIG_fail;
29459 }
29460 {
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29463
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 {
29468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29469 }
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29477 PyObject *resultobj;
29478 wxWindow *arg1 = (wxWindow *) 0 ;
29479 int arg2 ;
29480 bool result;
29481 PyObject * obj0 = 0 ;
29482 PyObject * obj1 = 0 ;
29483 char *kwnames[] = {
29484 (char *) "self",(char *) "hotkeyId", NULL
29485 };
29486
29487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29489 if (SWIG_arg_fail(1)) SWIG_fail;
29490 {
29491 arg2 = (int)(SWIG_As_int(obj1));
29492 if (SWIG_arg_fail(2)) SWIG_fail;
29493 }
29494 {
29495 PyThreadState* __tstate = wxPyBeginAllowThreads();
29496 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29497
29498 wxPyEndAllowThreads(__tstate);
29499 if (PyErr_Occurred()) SWIG_fail;
29500 }
29501 {
29502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29503 }
29504 return resultobj;
29505 fail:
29506 return NULL;
29507 }
29508
29509
29510 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29511 PyObject *resultobj;
29512 wxWindow *arg1 = (wxWindow *) 0 ;
29513 wxPoint *arg2 = 0 ;
29514 wxPoint result;
29515 wxPoint temp2 ;
29516 PyObject * obj0 = 0 ;
29517 PyObject * obj1 = 0 ;
29518 char *kwnames[] = {
29519 (char *) "self",(char *) "pt", NULL
29520 };
29521
29522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29524 if (SWIG_arg_fail(1)) SWIG_fail;
29525 {
29526 arg2 = &temp2;
29527 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29528 }
29529 {
29530 PyThreadState* __tstate = wxPyBeginAllowThreads();
29531 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29532
29533 wxPyEndAllowThreads(__tstate);
29534 if (PyErr_Occurred()) SWIG_fail;
29535 }
29536 {
29537 wxPoint * resultptr;
29538 resultptr = new wxPoint((wxPoint &)(result));
29539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29540 }
29541 return resultobj;
29542 fail:
29543 return NULL;
29544 }
29545
29546
29547 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29548 PyObject *resultobj;
29549 wxWindow *arg1 = (wxWindow *) 0 ;
29550 wxSize *arg2 = 0 ;
29551 wxSize result;
29552 wxSize temp2 ;
29553 PyObject * obj0 = 0 ;
29554 PyObject * obj1 = 0 ;
29555 char *kwnames[] = {
29556 (char *) "self",(char *) "sz", NULL
29557 };
29558
29559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29561 if (SWIG_arg_fail(1)) SWIG_fail;
29562 {
29563 arg2 = &temp2;
29564 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29565 }
29566 {
29567 PyThreadState* __tstate = wxPyBeginAllowThreads();
29568 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29569
29570 wxPyEndAllowThreads(__tstate);
29571 if (PyErr_Occurred()) SWIG_fail;
29572 }
29573 {
29574 wxSize * resultptr;
29575 resultptr = new wxSize((wxSize &)(result));
29576 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29577 }
29578 return resultobj;
29579 fail:
29580 return NULL;
29581 }
29582
29583
29584 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29585 PyObject *resultobj;
29586 wxWindow *arg1 = (wxWindow *) 0 ;
29587 wxPoint *arg2 = 0 ;
29588 wxPoint result;
29589 wxPoint temp2 ;
29590 PyObject * obj0 = 0 ;
29591 PyObject * obj1 = 0 ;
29592 char *kwnames[] = {
29593 (char *) "self",(char *) "pt", NULL
29594 };
29595
29596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29598 if (SWIG_arg_fail(1)) SWIG_fail;
29599 {
29600 arg2 = &temp2;
29601 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29602 }
29603 {
29604 PyThreadState* __tstate = wxPyBeginAllowThreads();
29605 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29606
29607 wxPyEndAllowThreads(__tstate);
29608 if (PyErr_Occurred()) SWIG_fail;
29609 }
29610 {
29611 wxPoint * resultptr;
29612 resultptr = new wxPoint((wxPoint &)(result));
29613 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29614 }
29615 return resultobj;
29616 fail:
29617 return NULL;
29618 }
29619
29620
29621 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29622 PyObject *resultobj;
29623 wxWindow *arg1 = (wxWindow *) 0 ;
29624 wxSize *arg2 = 0 ;
29625 wxSize result;
29626 wxSize temp2 ;
29627 PyObject * obj0 = 0 ;
29628 PyObject * obj1 = 0 ;
29629 char *kwnames[] = {
29630 (char *) "self",(char *) "sz", NULL
29631 };
29632
29633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29635 if (SWIG_arg_fail(1)) SWIG_fail;
29636 {
29637 arg2 = &temp2;
29638 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29639 }
29640 {
29641 PyThreadState* __tstate = wxPyBeginAllowThreads();
29642 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29643
29644 wxPyEndAllowThreads(__tstate);
29645 if (PyErr_Occurred()) SWIG_fail;
29646 }
29647 {
29648 wxSize * resultptr;
29649 resultptr = new wxSize((wxSize &)(result));
29650 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29651 }
29652 return resultobj;
29653 fail:
29654 return NULL;
29655 }
29656
29657
29658 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29659 PyObject *resultobj;
29660 wxWindow *arg1 = (wxWindow *) 0 ;
29661 wxPoint *arg2 = 0 ;
29662 wxPoint result;
29663 wxPoint temp2 ;
29664 PyObject * obj0 = 0 ;
29665 PyObject * obj1 = 0 ;
29666 char *kwnames[] = {
29667 (char *) "self",(char *) "pt", NULL
29668 };
29669
29670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29672 if (SWIG_arg_fail(1)) SWIG_fail;
29673 {
29674 arg2 = &temp2;
29675 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29676 }
29677 {
29678 PyThreadState* __tstate = wxPyBeginAllowThreads();
29679 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29680
29681 wxPyEndAllowThreads(__tstate);
29682 if (PyErr_Occurred()) SWIG_fail;
29683 }
29684 {
29685 wxPoint * resultptr;
29686 resultptr = new wxPoint((wxPoint &)(result));
29687 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29688 }
29689 return resultobj;
29690 fail:
29691 return NULL;
29692 }
29693
29694
29695 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29696 PyObject *resultobj;
29697 wxWindow *arg1 = (wxWindow *) 0 ;
29698 wxSize *arg2 = 0 ;
29699 wxSize result;
29700 wxSize temp2 ;
29701 PyObject * obj0 = 0 ;
29702 PyObject * obj1 = 0 ;
29703 char *kwnames[] = {
29704 (char *) "self",(char *) "sz", NULL
29705 };
29706
29707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29709 if (SWIG_arg_fail(1)) SWIG_fail;
29710 {
29711 arg2 = &temp2;
29712 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29713 }
29714 {
29715 PyThreadState* __tstate = wxPyBeginAllowThreads();
29716 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29717
29718 wxPyEndAllowThreads(__tstate);
29719 if (PyErr_Occurred()) SWIG_fail;
29720 }
29721 {
29722 wxSize * resultptr;
29723 resultptr = new wxSize((wxSize &)(result));
29724 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29725 }
29726 return resultobj;
29727 fail:
29728 return NULL;
29729 }
29730
29731
29732 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29733 PyObject *resultobj;
29734 wxWindow *arg1 = (wxWindow *) 0 ;
29735 int arg2 ;
29736 int arg3 ;
29737 PyObject * obj0 = 0 ;
29738 PyObject * obj1 = 0 ;
29739 PyObject * obj2 = 0 ;
29740 char *kwnames[] = {
29741 (char *) "self",(char *) "x",(char *) "y", NULL
29742 };
29743
29744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29746 if (SWIG_arg_fail(1)) SWIG_fail;
29747 {
29748 arg2 = (int)(SWIG_As_int(obj1));
29749 if (SWIG_arg_fail(2)) SWIG_fail;
29750 }
29751 {
29752 arg3 = (int)(SWIG_As_int(obj2));
29753 if (SWIG_arg_fail(3)) SWIG_fail;
29754 }
29755 {
29756 PyThreadState* __tstate = wxPyBeginAllowThreads();
29757 (arg1)->WarpPointer(arg2,arg3);
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_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29770 PyObject *resultobj;
29771 wxWindow *arg1 = (wxWindow *) 0 ;
29772 PyObject * obj0 = 0 ;
29773 char *kwnames[] = {
29774 (char *) "self", NULL
29775 };
29776
29777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29779 if (SWIG_arg_fail(1)) SWIG_fail;
29780 {
29781 PyThreadState* __tstate = wxPyBeginAllowThreads();
29782 (arg1)->CaptureMouse();
29783
29784 wxPyEndAllowThreads(__tstate);
29785 if (PyErr_Occurred()) SWIG_fail;
29786 }
29787 Py_INCREF(Py_None); resultobj = Py_None;
29788 return resultobj;
29789 fail:
29790 return NULL;
29791 }
29792
29793
29794 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29795 PyObject *resultobj;
29796 wxWindow *arg1 = (wxWindow *) 0 ;
29797 PyObject * obj0 = 0 ;
29798 char *kwnames[] = {
29799 (char *) "self", NULL
29800 };
29801
29802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29804 if (SWIG_arg_fail(1)) SWIG_fail;
29805 {
29806 PyThreadState* __tstate = wxPyBeginAllowThreads();
29807 (arg1)->ReleaseMouse();
29808
29809 wxPyEndAllowThreads(__tstate);
29810 if (PyErr_Occurred()) SWIG_fail;
29811 }
29812 Py_INCREF(Py_None); resultobj = Py_None;
29813 return resultobj;
29814 fail:
29815 return NULL;
29816 }
29817
29818
29819 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29820 PyObject *resultobj;
29821 wxWindow *result;
29822 char *kwnames[] = {
29823 NULL
29824 };
29825
29826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29827 {
29828 if (!wxPyCheckForApp()) SWIG_fail;
29829 PyThreadState* __tstate = wxPyBeginAllowThreads();
29830 result = (wxWindow *)wxWindow::GetCapture();
29831
29832 wxPyEndAllowThreads(__tstate);
29833 if (PyErr_Occurred()) SWIG_fail;
29834 }
29835 {
29836 resultobj = wxPyMake_wxObject(result, 0);
29837 }
29838 return resultobj;
29839 fail:
29840 return NULL;
29841 }
29842
29843
29844 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29845 PyObject *resultobj;
29846 wxWindow *arg1 = (wxWindow *) 0 ;
29847 bool result;
29848 PyObject * obj0 = 0 ;
29849 char *kwnames[] = {
29850 (char *) "self", NULL
29851 };
29852
29853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29855 if (SWIG_arg_fail(1)) SWIG_fail;
29856 {
29857 PyThreadState* __tstate = wxPyBeginAllowThreads();
29858 result = (bool)((wxWindow const *)arg1)->HasCapture();
29859
29860 wxPyEndAllowThreads(__tstate);
29861 if (PyErr_Occurred()) SWIG_fail;
29862 }
29863 {
29864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29865 }
29866 return resultobj;
29867 fail:
29868 return NULL;
29869 }
29870
29871
29872 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29873 PyObject *resultobj;
29874 wxWindow *arg1 = (wxWindow *) 0 ;
29875 bool arg2 = (bool) true ;
29876 wxRect *arg3 = (wxRect *) NULL ;
29877 PyObject * obj0 = 0 ;
29878 PyObject * obj1 = 0 ;
29879 PyObject * obj2 = 0 ;
29880 char *kwnames[] = {
29881 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29882 };
29883
29884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29886 if (SWIG_arg_fail(1)) SWIG_fail;
29887 if (obj1) {
29888 {
29889 arg2 = (bool)(SWIG_As_bool(obj1));
29890 if (SWIG_arg_fail(2)) SWIG_fail;
29891 }
29892 }
29893 if (obj2) {
29894 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29895 if (SWIG_arg_fail(3)) SWIG_fail;
29896 }
29897 {
29898 PyThreadState* __tstate = wxPyBeginAllowThreads();
29899 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29900
29901 wxPyEndAllowThreads(__tstate);
29902 if (PyErr_Occurred()) SWIG_fail;
29903 }
29904 Py_INCREF(Py_None); resultobj = Py_None;
29905 return resultobj;
29906 fail:
29907 return NULL;
29908 }
29909
29910
29911 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29912 PyObject *resultobj;
29913 wxWindow *arg1 = (wxWindow *) 0 ;
29914 wxRect *arg2 = 0 ;
29915 bool arg3 = (bool) true ;
29916 wxRect temp2 ;
29917 PyObject * obj0 = 0 ;
29918 PyObject * obj1 = 0 ;
29919 PyObject * obj2 = 0 ;
29920 char *kwnames[] = {
29921 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29922 };
29923
29924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29926 if (SWIG_arg_fail(1)) SWIG_fail;
29927 {
29928 arg2 = &temp2;
29929 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29930 }
29931 if (obj2) {
29932 {
29933 arg3 = (bool)(SWIG_As_bool(obj2));
29934 if (SWIG_arg_fail(3)) SWIG_fail;
29935 }
29936 }
29937 {
29938 PyThreadState* __tstate = wxPyBeginAllowThreads();
29939 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29940
29941 wxPyEndAllowThreads(__tstate);
29942 if (PyErr_Occurred()) SWIG_fail;
29943 }
29944 Py_INCREF(Py_None); resultobj = Py_None;
29945 return resultobj;
29946 fail:
29947 return NULL;
29948 }
29949
29950
29951 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29952 PyObject *resultobj;
29953 wxWindow *arg1 = (wxWindow *) 0 ;
29954 PyObject * obj0 = 0 ;
29955 char *kwnames[] = {
29956 (char *) "self", NULL
29957 };
29958
29959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29961 if (SWIG_arg_fail(1)) SWIG_fail;
29962 {
29963 PyThreadState* __tstate = wxPyBeginAllowThreads();
29964 (arg1)->Update();
29965
29966 wxPyEndAllowThreads(__tstate);
29967 if (PyErr_Occurred()) SWIG_fail;
29968 }
29969 Py_INCREF(Py_None); resultobj = Py_None;
29970 return resultobj;
29971 fail:
29972 return NULL;
29973 }
29974
29975
29976 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29977 PyObject *resultobj;
29978 wxWindow *arg1 = (wxWindow *) 0 ;
29979 PyObject * obj0 = 0 ;
29980 char *kwnames[] = {
29981 (char *) "self", NULL
29982 };
29983
29984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29986 if (SWIG_arg_fail(1)) SWIG_fail;
29987 {
29988 PyThreadState* __tstate = wxPyBeginAllowThreads();
29989 (arg1)->ClearBackground();
29990
29991 wxPyEndAllowThreads(__tstate);
29992 if (PyErr_Occurred()) SWIG_fail;
29993 }
29994 Py_INCREF(Py_None); resultobj = Py_None;
29995 return resultobj;
29996 fail:
29997 return NULL;
29998 }
29999
30000
30001 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
30002 PyObject *resultobj;
30003 wxWindow *arg1 = (wxWindow *) 0 ;
30004 PyObject * obj0 = 0 ;
30005 char *kwnames[] = {
30006 (char *) "self", NULL
30007 };
30008
30009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
30010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30011 if (SWIG_arg_fail(1)) SWIG_fail;
30012 {
30013 PyThreadState* __tstate = wxPyBeginAllowThreads();
30014 (arg1)->Freeze();
30015
30016 wxPyEndAllowThreads(__tstate);
30017 if (PyErr_Occurred()) SWIG_fail;
30018 }
30019 Py_INCREF(Py_None); resultobj = Py_None;
30020 return resultobj;
30021 fail:
30022 return NULL;
30023 }
30024
30025
30026 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
30027 PyObject *resultobj;
30028 wxWindow *arg1 = (wxWindow *) 0 ;
30029 PyObject * obj0 = 0 ;
30030 char *kwnames[] = {
30031 (char *) "self", NULL
30032 };
30033
30034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
30035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30036 if (SWIG_arg_fail(1)) SWIG_fail;
30037 {
30038 PyThreadState* __tstate = wxPyBeginAllowThreads();
30039 (arg1)->Thaw();
30040
30041 wxPyEndAllowThreads(__tstate);
30042 if (PyErr_Occurred()) SWIG_fail;
30043 }
30044 Py_INCREF(Py_None); resultobj = Py_None;
30045 return resultobj;
30046 fail:
30047 return NULL;
30048 }
30049
30050
30051 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
30052 PyObject *resultobj;
30053 wxWindow *arg1 = (wxWindow *) 0 ;
30054 wxDC *arg2 = 0 ;
30055 PyObject * obj0 = 0 ;
30056 PyObject * obj1 = 0 ;
30057 char *kwnames[] = {
30058 (char *) "self",(char *) "dc", NULL
30059 };
30060
30061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
30062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30063 if (SWIG_arg_fail(1)) SWIG_fail;
30064 {
30065 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
30066 if (SWIG_arg_fail(2)) SWIG_fail;
30067 if (arg2 == NULL) {
30068 SWIG_null_ref("wxDC");
30069 }
30070 if (SWIG_arg_fail(2)) SWIG_fail;
30071 }
30072 {
30073 PyThreadState* __tstate = wxPyBeginAllowThreads();
30074 (arg1)->PrepareDC(*arg2);
30075
30076 wxPyEndAllowThreads(__tstate);
30077 if (PyErr_Occurred()) SWIG_fail;
30078 }
30079 Py_INCREF(Py_None); resultobj = Py_None;
30080 return resultobj;
30081 fail:
30082 return NULL;
30083 }
30084
30085
30086 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30087 PyObject *resultobj;
30088 wxWindow *arg1 = (wxWindow *) 0 ;
30089 wxRegion *result;
30090 PyObject * obj0 = 0 ;
30091 char *kwnames[] = {
30092 (char *) "self", NULL
30093 };
30094
30095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30097 if (SWIG_arg_fail(1)) SWIG_fail;
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 {
30101 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30102 result = (wxRegion *) &_result_ref;
30103 }
30104
30105 wxPyEndAllowThreads(__tstate);
30106 if (PyErr_Occurred()) SWIG_fail;
30107 }
30108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30109 return resultobj;
30110 fail:
30111 return NULL;
30112 }
30113
30114
30115 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30116 PyObject *resultobj;
30117 wxWindow *arg1 = (wxWindow *) 0 ;
30118 wxRect result;
30119 PyObject * obj0 = 0 ;
30120 char *kwnames[] = {
30121 (char *) "self", NULL
30122 };
30123
30124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30126 if (SWIG_arg_fail(1)) SWIG_fail;
30127 {
30128 PyThreadState* __tstate = wxPyBeginAllowThreads();
30129 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30130
30131 wxPyEndAllowThreads(__tstate);
30132 if (PyErr_Occurred()) SWIG_fail;
30133 }
30134 {
30135 wxRect * resultptr;
30136 resultptr = new wxRect((wxRect &)(result));
30137 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30138 }
30139 return resultobj;
30140 fail:
30141 return NULL;
30142 }
30143
30144
30145 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30146 PyObject *resultobj;
30147 wxWindow *arg1 = (wxWindow *) 0 ;
30148 int arg2 ;
30149 int arg3 ;
30150 int arg4 = (int) 1 ;
30151 int arg5 = (int) 1 ;
30152 bool result;
30153 PyObject * obj0 = 0 ;
30154 PyObject * obj1 = 0 ;
30155 PyObject * obj2 = 0 ;
30156 PyObject * obj3 = 0 ;
30157 PyObject * obj4 = 0 ;
30158 char *kwnames[] = {
30159 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30160 };
30161
30162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30164 if (SWIG_arg_fail(1)) SWIG_fail;
30165 {
30166 arg2 = (int)(SWIG_As_int(obj1));
30167 if (SWIG_arg_fail(2)) SWIG_fail;
30168 }
30169 {
30170 arg3 = (int)(SWIG_As_int(obj2));
30171 if (SWIG_arg_fail(3)) SWIG_fail;
30172 }
30173 if (obj3) {
30174 {
30175 arg4 = (int)(SWIG_As_int(obj3));
30176 if (SWIG_arg_fail(4)) SWIG_fail;
30177 }
30178 }
30179 if (obj4) {
30180 {
30181 arg5 = (int)(SWIG_As_int(obj4));
30182 if (SWIG_arg_fail(5)) SWIG_fail;
30183 }
30184 }
30185 {
30186 PyThreadState* __tstate = wxPyBeginAllowThreads();
30187 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30188
30189 wxPyEndAllowThreads(__tstate);
30190 if (PyErr_Occurred()) SWIG_fail;
30191 }
30192 {
30193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30194 }
30195 return resultobj;
30196 fail:
30197 return NULL;
30198 }
30199
30200
30201 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30202 PyObject *resultobj;
30203 wxWindow *arg1 = (wxWindow *) 0 ;
30204 wxPoint *arg2 = 0 ;
30205 bool result;
30206 wxPoint temp2 ;
30207 PyObject * obj0 = 0 ;
30208 PyObject * obj1 = 0 ;
30209 char *kwnames[] = {
30210 (char *) "self",(char *) "pt", NULL
30211 };
30212
30213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30215 if (SWIG_arg_fail(1)) SWIG_fail;
30216 {
30217 arg2 = &temp2;
30218 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30219 }
30220 {
30221 PyThreadState* __tstate = wxPyBeginAllowThreads();
30222 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30223
30224 wxPyEndAllowThreads(__tstate);
30225 if (PyErr_Occurred()) SWIG_fail;
30226 }
30227 {
30228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30229 }
30230 return resultobj;
30231 fail:
30232 return NULL;
30233 }
30234
30235
30236 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30237 PyObject *resultobj;
30238 wxWindow *arg1 = (wxWindow *) 0 ;
30239 wxRect *arg2 = 0 ;
30240 bool result;
30241 wxRect temp2 ;
30242 PyObject * obj0 = 0 ;
30243 PyObject * obj1 = 0 ;
30244 char *kwnames[] = {
30245 (char *) "self",(char *) "rect", NULL
30246 };
30247
30248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30250 if (SWIG_arg_fail(1)) SWIG_fail;
30251 {
30252 arg2 = &temp2;
30253 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30254 }
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30258
30259 wxPyEndAllowThreads(__tstate);
30260 if (PyErr_Occurred()) SWIG_fail;
30261 }
30262 {
30263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30264 }
30265 return resultobj;
30266 fail:
30267 return NULL;
30268 }
30269
30270
30271 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30272 PyObject *resultobj;
30273 wxWindow *arg1 = (wxWindow *) 0 ;
30274 wxVisualAttributes result;
30275 PyObject * obj0 = 0 ;
30276 char *kwnames[] = {
30277 (char *) "self", NULL
30278 };
30279
30280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30282 if (SWIG_arg_fail(1)) SWIG_fail;
30283 {
30284 PyThreadState* __tstate = wxPyBeginAllowThreads();
30285 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30286
30287 wxPyEndAllowThreads(__tstate);
30288 if (PyErr_Occurred()) SWIG_fail;
30289 }
30290 {
30291 wxVisualAttributes * resultptr;
30292 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
30293 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30294 }
30295 return resultobj;
30296 fail:
30297 return NULL;
30298 }
30299
30300
30301 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30302 PyObject *resultobj;
30303 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30304 wxVisualAttributes result;
30305 PyObject * obj0 = 0 ;
30306 char *kwnames[] = {
30307 (char *) "variant", NULL
30308 };
30309
30310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30311 if (obj0) {
30312 {
30313 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
30314 if (SWIG_arg_fail(1)) SWIG_fail;
30315 }
30316 }
30317 {
30318 if (!wxPyCheckForApp()) SWIG_fail;
30319 PyThreadState* __tstate = wxPyBeginAllowThreads();
30320 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
30321
30322 wxPyEndAllowThreads(__tstate);
30323 if (PyErr_Occurred()) SWIG_fail;
30324 }
30325 {
30326 wxVisualAttributes * resultptr;
30327 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
30328 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30329 }
30330 return resultobj;
30331 fail:
30332 return NULL;
30333 }
30334
30335
30336 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30337 PyObject *resultobj;
30338 wxWindow *arg1 = (wxWindow *) 0 ;
30339 wxColour *arg2 = 0 ;
30340 bool result;
30341 wxColour temp2 ;
30342 PyObject * obj0 = 0 ;
30343 PyObject * obj1 = 0 ;
30344 char *kwnames[] = {
30345 (char *) "self",(char *) "colour", NULL
30346 };
30347
30348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30350 if (SWIG_arg_fail(1)) SWIG_fail;
30351 {
30352 arg2 = &temp2;
30353 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30354 }
30355 {
30356 PyThreadState* __tstate = wxPyBeginAllowThreads();
30357 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30358
30359 wxPyEndAllowThreads(__tstate);
30360 if (PyErr_Occurred()) SWIG_fail;
30361 }
30362 {
30363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30364 }
30365 return resultobj;
30366 fail:
30367 return NULL;
30368 }
30369
30370
30371 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30372 PyObject *resultobj;
30373 wxWindow *arg1 = (wxWindow *) 0 ;
30374 wxColour *arg2 = 0 ;
30375 wxColour temp2 ;
30376 PyObject * obj0 = 0 ;
30377 PyObject * obj1 = 0 ;
30378 char *kwnames[] = {
30379 (char *) "self",(char *) "colour", NULL
30380 };
30381
30382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30384 if (SWIG_arg_fail(1)) SWIG_fail;
30385 {
30386 arg2 = &temp2;
30387 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30388 }
30389 {
30390 PyThreadState* __tstate = wxPyBeginAllowThreads();
30391 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30392
30393 wxPyEndAllowThreads(__tstate);
30394 if (PyErr_Occurred()) SWIG_fail;
30395 }
30396 Py_INCREF(Py_None); resultobj = Py_None;
30397 return resultobj;
30398 fail:
30399 return NULL;
30400 }
30401
30402
30403 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30404 PyObject *resultobj;
30405 wxWindow *arg1 = (wxWindow *) 0 ;
30406 wxColour *arg2 = 0 ;
30407 bool result;
30408 wxColour temp2 ;
30409 PyObject * obj0 = 0 ;
30410 PyObject * obj1 = 0 ;
30411 char *kwnames[] = {
30412 (char *) "self",(char *) "colour", NULL
30413 };
30414
30415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30417 if (SWIG_arg_fail(1)) SWIG_fail;
30418 {
30419 arg2 = &temp2;
30420 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30421 }
30422 {
30423 PyThreadState* __tstate = wxPyBeginAllowThreads();
30424 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30425
30426 wxPyEndAllowThreads(__tstate);
30427 if (PyErr_Occurred()) SWIG_fail;
30428 }
30429 {
30430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30431 }
30432 return resultobj;
30433 fail:
30434 return NULL;
30435 }
30436
30437
30438 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30439 PyObject *resultobj;
30440 wxWindow *arg1 = (wxWindow *) 0 ;
30441 wxColour *arg2 = 0 ;
30442 wxColour temp2 ;
30443 PyObject * obj0 = 0 ;
30444 PyObject * obj1 = 0 ;
30445 char *kwnames[] = {
30446 (char *) "self",(char *) "colour", NULL
30447 };
30448
30449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30451 if (SWIG_arg_fail(1)) SWIG_fail;
30452 {
30453 arg2 = &temp2;
30454 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30455 }
30456 {
30457 PyThreadState* __tstate = wxPyBeginAllowThreads();
30458 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30459
30460 wxPyEndAllowThreads(__tstate);
30461 if (PyErr_Occurred()) SWIG_fail;
30462 }
30463 Py_INCREF(Py_None); resultobj = Py_None;
30464 return resultobj;
30465 fail:
30466 return NULL;
30467 }
30468
30469
30470 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30471 PyObject *resultobj;
30472 wxWindow *arg1 = (wxWindow *) 0 ;
30473 wxColour result;
30474 PyObject * obj0 = 0 ;
30475 char *kwnames[] = {
30476 (char *) "self", NULL
30477 };
30478
30479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30481 if (SWIG_arg_fail(1)) SWIG_fail;
30482 {
30483 PyThreadState* __tstate = wxPyBeginAllowThreads();
30484 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30485
30486 wxPyEndAllowThreads(__tstate);
30487 if (PyErr_Occurred()) SWIG_fail;
30488 }
30489 {
30490 wxColour * resultptr;
30491 resultptr = new wxColour((wxColour &)(result));
30492 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30493 }
30494 return resultobj;
30495 fail:
30496 return NULL;
30497 }
30498
30499
30500 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30501 PyObject *resultobj;
30502 wxWindow *arg1 = (wxWindow *) 0 ;
30503 wxColour result;
30504 PyObject * obj0 = 0 ;
30505 char *kwnames[] = {
30506 (char *) "self", NULL
30507 };
30508
30509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30511 if (SWIG_arg_fail(1)) SWIG_fail;
30512 {
30513 PyThreadState* __tstate = wxPyBeginAllowThreads();
30514 result = ((wxWindow const *)arg1)->GetForegroundColour();
30515
30516 wxPyEndAllowThreads(__tstate);
30517 if (PyErr_Occurred()) SWIG_fail;
30518 }
30519 {
30520 wxColour * resultptr;
30521 resultptr = new wxColour((wxColour &)(result));
30522 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30523 }
30524 return resultobj;
30525 fail:
30526 return NULL;
30527 }
30528
30529
30530 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30531 PyObject *resultobj;
30532 wxWindow *arg1 = (wxWindow *) 0 ;
30533 bool result;
30534 PyObject * obj0 = 0 ;
30535 char *kwnames[] = {
30536 (char *) "self", NULL
30537 };
30538
30539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30541 if (SWIG_arg_fail(1)) SWIG_fail;
30542 {
30543 PyThreadState* __tstate = wxPyBeginAllowThreads();
30544 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30545
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 {
30550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30551 }
30552 return resultobj;
30553 fail:
30554 return NULL;
30555 }
30556
30557
30558 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30559 PyObject *resultobj;
30560 wxWindow *arg1 = (wxWindow *) 0 ;
30561 bool result;
30562 PyObject * obj0 = 0 ;
30563 char *kwnames[] = {
30564 (char *) "self", NULL
30565 };
30566
30567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30569 if (SWIG_arg_fail(1)) SWIG_fail;
30570 {
30571 PyThreadState* __tstate = wxPyBeginAllowThreads();
30572 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30573
30574 wxPyEndAllowThreads(__tstate);
30575 if (PyErr_Occurred()) SWIG_fail;
30576 }
30577 {
30578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30579 }
30580 return resultobj;
30581 fail:
30582 return NULL;
30583 }
30584
30585
30586 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30587 PyObject *resultobj;
30588 wxWindow *arg1 = (wxWindow *) 0 ;
30589 wxBackgroundStyle arg2 ;
30590 bool result;
30591 PyObject * obj0 = 0 ;
30592 PyObject * obj1 = 0 ;
30593 char *kwnames[] = {
30594 (char *) "self",(char *) "style", NULL
30595 };
30596
30597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30599 if (SWIG_arg_fail(1)) SWIG_fail;
30600 {
30601 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
30602 if (SWIG_arg_fail(2)) SWIG_fail;
30603 }
30604 {
30605 PyThreadState* __tstate = wxPyBeginAllowThreads();
30606 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
30607
30608 wxPyEndAllowThreads(__tstate);
30609 if (PyErr_Occurred()) SWIG_fail;
30610 }
30611 {
30612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30613 }
30614 return resultobj;
30615 fail:
30616 return NULL;
30617 }
30618
30619
30620 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30621 PyObject *resultobj;
30622 wxWindow *arg1 = (wxWindow *) 0 ;
30623 wxBackgroundStyle result;
30624 PyObject * obj0 = 0 ;
30625 char *kwnames[] = {
30626 (char *) "self", NULL
30627 };
30628
30629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30631 if (SWIG_arg_fail(1)) SWIG_fail;
30632 {
30633 PyThreadState* __tstate = wxPyBeginAllowThreads();
30634 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30635
30636 wxPyEndAllowThreads(__tstate);
30637 if (PyErr_Occurred()) SWIG_fail;
30638 }
30639 resultobj = SWIG_From_int((result));
30640 return resultobj;
30641 fail:
30642 return NULL;
30643 }
30644
30645
30646 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30647 PyObject *resultobj;
30648 wxWindow *arg1 = (wxWindow *) 0 ;
30649 bool result;
30650 PyObject * obj0 = 0 ;
30651 char *kwnames[] = {
30652 (char *) "self", NULL
30653 };
30654
30655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30657 if (SWIG_arg_fail(1)) SWIG_fail;
30658 {
30659 PyThreadState* __tstate = wxPyBeginAllowThreads();
30660 result = (bool)(arg1)->HasTransparentBackground();
30661
30662 wxPyEndAllowThreads(__tstate);
30663 if (PyErr_Occurred()) SWIG_fail;
30664 }
30665 {
30666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30667 }
30668 return resultobj;
30669 fail:
30670 return NULL;
30671 }
30672
30673
30674 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30675 PyObject *resultobj;
30676 wxWindow *arg1 = (wxWindow *) 0 ;
30677 wxCursor *arg2 = 0 ;
30678 bool result;
30679 PyObject * obj0 = 0 ;
30680 PyObject * obj1 = 0 ;
30681 char *kwnames[] = {
30682 (char *) "self",(char *) "cursor", NULL
30683 };
30684
30685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30687 if (SWIG_arg_fail(1)) SWIG_fail;
30688 {
30689 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30690 if (SWIG_arg_fail(2)) SWIG_fail;
30691 if (arg2 == NULL) {
30692 SWIG_null_ref("wxCursor");
30693 }
30694 if (SWIG_arg_fail(2)) SWIG_fail;
30695 }
30696 {
30697 PyThreadState* __tstate = wxPyBeginAllowThreads();
30698 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30699
30700 wxPyEndAllowThreads(__tstate);
30701 if (PyErr_Occurred()) SWIG_fail;
30702 }
30703 {
30704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30705 }
30706 return resultobj;
30707 fail:
30708 return NULL;
30709 }
30710
30711
30712 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30713 PyObject *resultobj;
30714 wxWindow *arg1 = (wxWindow *) 0 ;
30715 wxCursor result;
30716 PyObject * obj0 = 0 ;
30717 char *kwnames[] = {
30718 (char *) "self", NULL
30719 };
30720
30721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30723 if (SWIG_arg_fail(1)) SWIG_fail;
30724 {
30725 PyThreadState* __tstate = wxPyBeginAllowThreads();
30726 result = (arg1)->GetCursor();
30727
30728 wxPyEndAllowThreads(__tstate);
30729 if (PyErr_Occurred()) SWIG_fail;
30730 }
30731 {
30732 wxCursor * resultptr;
30733 resultptr = new wxCursor((wxCursor &)(result));
30734 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30735 }
30736 return resultobj;
30737 fail:
30738 return NULL;
30739 }
30740
30741
30742 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30743 PyObject *resultobj;
30744 wxWindow *arg1 = (wxWindow *) 0 ;
30745 wxFont *arg2 = 0 ;
30746 bool result;
30747 PyObject * obj0 = 0 ;
30748 PyObject * obj1 = 0 ;
30749 char *kwnames[] = {
30750 (char *) "self",(char *) "font", NULL
30751 };
30752
30753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30755 if (SWIG_arg_fail(1)) SWIG_fail;
30756 {
30757 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30758 if (SWIG_arg_fail(2)) SWIG_fail;
30759 if (arg2 == NULL) {
30760 SWIG_null_ref("wxFont");
30761 }
30762 if (SWIG_arg_fail(2)) SWIG_fail;
30763 }
30764 {
30765 PyThreadState* __tstate = wxPyBeginAllowThreads();
30766 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30767
30768 wxPyEndAllowThreads(__tstate);
30769 if (PyErr_Occurred()) SWIG_fail;
30770 }
30771 {
30772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30773 }
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30781 PyObject *resultobj;
30782 wxWindow *arg1 = (wxWindow *) 0 ;
30783 wxFont *arg2 = 0 ;
30784 PyObject * obj0 = 0 ;
30785 PyObject * obj1 = 0 ;
30786 char *kwnames[] = {
30787 (char *) "self",(char *) "font", NULL
30788 };
30789
30790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30792 if (SWIG_arg_fail(1)) SWIG_fail;
30793 {
30794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30795 if (SWIG_arg_fail(2)) SWIG_fail;
30796 if (arg2 == NULL) {
30797 SWIG_null_ref("wxFont");
30798 }
30799 if (SWIG_arg_fail(2)) SWIG_fail;
30800 }
30801 {
30802 PyThreadState* __tstate = wxPyBeginAllowThreads();
30803 (arg1)->SetOwnFont((wxFont const &)*arg2);
30804
30805 wxPyEndAllowThreads(__tstate);
30806 if (PyErr_Occurred()) SWIG_fail;
30807 }
30808 Py_INCREF(Py_None); resultobj = Py_None;
30809 return resultobj;
30810 fail:
30811 return NULL;
30812 }
30813
30814
30815 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30816 PyObject *resultobj;
30817 wxWindow *arg1 = (wxWindow *) 0 ;
30818 wxFont result;
30819 PyObject * obj0 = 0 ;
30820 char *kwnames[] = {
30821 (char *) "self", NULL
30822 };
30823
30824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30826 if (SWIG_arg_fail(1)) SWIG_fail;
30827 {
30828 PyThreadState* __tstate = wxPyBeginAllowThreads();
30829 result = (arg1)->GetFont();
30830
30831 wxPyEndAllowThreads(__tstate);
30832 if (PyErr_Occurred()) SWIG_fail;
30833 }
30834 {
30835 wxFont * resultptr;
30836 resultptr = new wxFont((wxFont &)(result));
30837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30838 }
30839 return resultobj;
30840 fail:
30841 return NULL;
30842 }
30843
30844
30845 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30846 PyObject *resultobj;
30847 wxWindow *arg1 = (wxWindow *) 0 ;
30848 wxCaret *arg2 = (wxCaret *) 0 ;
30849 PyObject * obj0 = 0 ;
30850 PyObject * obj1 = 0 ;
30851 char *kwnames[] = {
30852 (char *) "self",(char *) "caret", NULL
30853 };
30854
30855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30857 if (SWIG_arg_fail(1)) SWIG_fail;
30858 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30859 if (SWIG_arg_fail(2)) SWIG_fail;
30860 {
30861 PyThreadState* __tstate = wxPyBeginAllowThreads();
30862 (arg1)->SetCaret(arg2);
30863
30864 wxPyEndAllowThreads(__tstate);
30865 if (PyErr_Occurred()) SWIG_fail;
30866 }
30867 Py_INCREF(Py_None); resultobj = Py_None;
30868 return resultobj;
30869 fail:
30870 return NULL;
30871 }
30872
30873
30874 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30875 PyObject *resultobj;
30876 wxWindow *arg1 = (wxWindow *) 0 ;
30877 wxCaret *result;
30878 PyObject * obj0 = 0 ;
30879 char *kwnames[] = {
30880 (char *) "self", NULL
30881 };
30882
30883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30885 if (SWIG_arg_fail(1)) SWIG_fail;
30886 {
30887 PyThreadState* __tstate = wxPyBeginAllowThreads();
30888 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30889
30890 wxPyEndAllowThreads(__tstate);
30891 if (PyErr_Occurred()) SWIG_fail;
30892 }
30893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30894 return resultobj;
30895 fail:
30896 return NULL;
30897 }
30898
30899
30900 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30901 PyObject *resultobj;
30902 wxWindow *arg1 = (wxWindow *) 0 ;
30903 int result;
30904 PyObject * obj0 = 0 ;
30905 char *kwnames[] = {
30906 (char *) "self", NULL
30907 };
30908
30909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30911 if (SWIG_arg_fail(1)) SWIG_fail;
30912 {
30913 PyThreadState* __tstate = wxPyBeginAllowThreads();
30914 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30915
30916 wxPyEndAllowThreads(__tstate);
30917 if (PyErr_Occurred()) SWIG_fail;
30918 }
30919 {
30920 resultobj = SWIG_From_int((int)(result));
30921 }
30922 return resultobj;
30923 fail:
30924 return NULL;
30925 }
30926
30927
30928 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30929 PyObject *resultobj;
30930 wxWindow *arg1 = (wxWindow *) 0 ;
30931 int result;
30932 PyObject * obj0 = 0 ;
30933 char *kwnames[] = {
30934 (char *) "self", NULL
30935 };
30936
30937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30939 if (SWIG_arg_fail(1)) SWIG_fail;
30940 {
30941 PyThreadState* __tstate = wxPyBeginAllowThreads();
30942 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30943
30944 wxPyEndAllowThreads(__tstate);
30945 if (PyErr_Occurred()) SWIG_fail;
30946 }
30947 {
30948 resultobj = SWIG_From_int((int)(result));
30949 }
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30957 PyObject *resultobj;
30958 wxWindow *arg1 = (wxWindow *) 0 ;
30959 wxString *arg2 = 0 ;
30960 int *arg3 = (int *) 0 ;
30961 int *arg4 = (int *) 0 ;
30962 bool temp2 = false ;
30963 int temp3 ;
30964 int res3 = 0 ;
30965 int temp4 ;
30966 int res4 = 0 ;
30967 PyObject * obj0 = 0 ;
30968 PyObject * obj1 = 0 ;
30969 char *kwnames[] = {
30970 (char *) "self",(char *) "string", NULL
30971 };
30972
30973 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30974 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30977 if (SWIG_arg_fail(1)) SWIG_fail;
30978 {
30979 arg2 = wxString_in_helper(obj1);
30980 if (arg2 == NULL) SWIG_fail;
30981 temp2 = true;
30982 }
30983 {
30984 PyThreadState* __tstate = wxPyBeginAllowThreads();
30985 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30986
30987 wxPyEndAllowThreads(__tstate);
30988 if (PyErr_Occurred()) SWIG_fail;
30989 }
30990 Py_INCREF(Py_None); resultobj = Py_None;
30991 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30992 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30993 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30994 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30995 {
30996 if (temp2)
30997 delete arg2;
30998 }
30999 return resultobj;
31000 fail:
31001 {
31002 if (temp2)
31003 delete arg2;
31004 }
31005 return NULL;
31006 }
31007
31008
31009 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31010 PyObject *resultobj;
31011 wxWindow *arg1 = (wxWindow *) 0 ;
31012 wxString *arg2 = 0 ;
31013 int *arg3 = (int *) 0 ;
31014 int *arg4 = (int *) 0 ;
31015 int *arg5 = (int *) 0 ;
31016 int *arg6 = (int *) 0 ;
31017 wxFont *arg7 = (wxFont *) NULL ;
31018 bool temp2 = false ;
31019 int temp3 ;
31020 int res3 = 0 ;
31021 int temp4 ;
31022 int res4 = 0 ;
31023 int temp5 ;
31024 int res5 = 0 ;
31025 int temp6 ;
31026 int res6 = 0 ;
31027 PyObject * obj0 = 0 ;
31028 PyObject * obj1 = 0 ;
31029 PyObject * obj2 = 0 ;
31030 char *kwnames[] = {
31031 (char *) "self",(char *) "string",(char *) "font", NULL
31032 };
31033
31034 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31035 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31036 arg5 = &temp5; res5 = SWIG_NEWOBJ;
31037 arg6 = &temp6; res6 = SWIG_NEWOBJ;
31038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
31039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31040 if (SWIG_arg_fail(1)) SWIG_fail;
31041 {
31042 arg2 = wxString_in_helper(obj1);
31043 if (arg2 == NULL) SWIG_fail;
31044 temp2 = true;
31045 }
31046 if (obj2) {
31047 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31048 if (SWIG_arg_fail(7)) SWIG_fail;
31049 }
31050 {
31051 PyThreadState* __tstate = wxPyBeginAllowThreads();
31052 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
31053
31054 wxPyEndAllowThreads(__tstate);
31055 if (PyErr_Occurred()) SWIG_fail;
31056 }
31057 Py_INCREF(Py_None); resultobj = Py_None;
31058 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31059 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31060 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31061 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31062 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
31063 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
31064 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
31065 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
31066 {
31067 if (temp2)
31068 delete arg2;
31069 }
31070 return resultobj;
31071 fail:
31072 {
31073 if (temp2)
31074 delete arg2;
31075 }
31076 return NULL;
31077 }
31078
31079
31080 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
31081 PyObject *resultobj;
31082 wxWindow *arg1 = (wxWindow *) 0 ;
31083 int *arg2 = (int *) 0 ;
31084 int *arg3 = (int *) 0 ;
31085 int temp2 ;
31086 int res2 = 0 ;
31087 int temp3 ;
31088 int res3 = 0 ;
31089 PyObject * obj0 = 0 ;
31090 PyObject * obj1 = 0 ;
31091 PyObject * obj2 = 0 ;
31092 char *kwnames[] = {
31093 (char *) "self",(char *) "x",(char *) "y", NULL
31094 };
31095
31096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31098 if (SWIG_arg_fail(1)) SWIG_fail;
31099 {
31100 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31101 temp2 = SWIG_As_int(obj1);
31102 if (SWIG_arg_fail(2)) SWIG_fail;
31103 arg2 = &temp2;
31104 res2 = SWIG_NEWOBJ;
31105 }
31106 }
31107 {
31108 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31109 temp3 = SWIG_As_int(obj2);
31110 if (SWIG_arg_fail(3)) SWIG_fail;
31111 arg3 = &temp3;
31112 res3 = SWIG_NEWOBJ;
31113 }
31114 }
31115 {
31116 PyThreadState* __tstate = wxPyBeginAllowThreads();
31117 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31118
31119 wxPyEndAllowThreads(__tstate);
31120 if (PyErr_Occurred()) SWIG_fail;
31121 }
31122 Py_INCREF(Py_None); resultobj = Py_None;
31123 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31124 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31125 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31126 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31127 return resultobj;
31128 fail:
31129 return NULL;
31130 }
31131
31132
31133 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31134 PyObject *resultobj;
31135 wxWindow *arg1 = (wxWindow *) 0 ;
31136 int *arg2 = (int *) 0 ;
31137 int *arg3 = (int *) 0 ;
31138 int temp2 ;
31139 int res2 = 0 ;
31140 int temp3 ;
31141 int res3 = 0 ;
31142 PyObject * obj0 = 0 ;
31143 PyObject * obj1 = 0 ;
31144 PyObject * obj2 = 0 ;
31145 char *kwnames[] = {
31146 (char *) "self",(char *) "x",(char *) "y", NULL
31147 };
31148
31149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31151 if (SWIG_arg_fail(1)) SWIG_fail;
31152 {
31153 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31154 temp2 = SWIG_As_int(obj1);
31155 if (SWIG_arg_fail(2)) SWIG_fail;
31156 arg2 = &temp2;
31157 res2 = SWIG_NEWOBJ;
31158 }
31159 }
31160 {
31161 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31162 temp3 = SWIG_As_int(obj2);
31163 if (SWIG_arg_fail(3)) SWIG_fail;
31164 arg3 = &temp3;
31165 res3 = SWIG_NEWOBJ;
31166 }
31167 }
31168 {
31169 PyThreadState* __tstate = wxPyBeginAllowThreads();
31170 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31171
31172 wxPyEndAllowThreads(__tstate);
31173 if (PyErr_Occurred()) SWIG_fail;
31174 }
31175 Py_INCREF(Py_None); resultobj = Py_None;
31176 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31177 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31178 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31179 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31180 return resultobj;
31181 fail:
31182 return NULL;
31183 }
31184
31185
31186 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31187 PyObject *resultobj;
31188 wxWindow *arg1 = (wxWindow *) 0 ;
31189 wxPoint *arg2 = 0 ;
31190 wxPoint result;
31191 wxPoint temp2 ;
31192 PyObject * obj0 = 0 ;
31193 PyObject * obj1 = 0 ;
31194 char *kwnames[] = {
31195 (char *) "self",(char *) "pt", NULL
31196 };
31197
31198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31200 if (SWIG_arg_fail(1)) SWIG_fail;
31201 {
31202 arg2 = &temp2;
31203 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31204 }
31205 {
31206 PyThreadState* __tstate = wxPyBeginAllowThreads();
31207 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31208
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 {
31213 wxPoint * resultptr;
31214 resultptr = new wxPoint((wxPoint &)(result));
31215 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31216 }
31217 return resultobj;
31218 fail:
31219 return NULL;
31220 }
31221
31222
31223 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31224 PyObject *resultobj;
31225 wxWindow *arg1 = (wxWindow *) 0 ;
31226 wxPoint *arg2 = 0 ;
31227 wxPoint result;
31228 wxPoint temp2 ;
31229 PyObject * obj0 = 0 ;
31230 PyObject * obj1 = 0 ;
31231 char *kwnames[] = {
31232 (char *) "self",(char *) "pt", NULL
31233 };
31234
31235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31237 if (SWIG_arg_fail(1)) SWIG_fail;
31238 {
31239 arg2 = &temp2;
31240 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31241 }
31242 {
31243 PyThreadState* __tstate = wxPyBeginAllowThreads();
31244 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31245
31246 wxPyEndAllowThreads(__tstate);
31247 if (PyErr_Occurred()) SWIG_fail;
31248 }
31249 {
31250 wxPoint * resultptr;
31251 resultptr = new wxPoint((wxPoint &)(result));
31252 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31253 }
31254 return resultobj;
31255 fail:
31256 return NULL;
31257 }
31258
31259
31260 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31261 PyObject *resultobj;
31262 wxWindow *arg1 = (wxWindow *) 0 ;
31263 int arg2 ;
31264 int arg3 ;
31265 wxHitTest result;
31266 PyObject * obj0 = 0 ;
31267 PyObject * obj1 = 0 ;
31268 PyObject * obj2 = 0 ;
31269 char *kwnames[] = {
31270 (char *) "self",(char *) "x",(char *) "y", NULL
31271 };
31272
31273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31275 if (SWIG_arg_fail(1)) SWIG_fail;
31276 {
31277 arg2 = (int)(SWIG_As_int(obj1));
31278 if (SWIG_arg_fail(2)) SWIG_fail;
31279 }
31280 {
31281 arg3 = (int)(SWIG_As_int(obj2));
31282 if (SWIG_arg_fail(3)) SWIG_fail;
31283 }
31284 {
31285 PyThreadState* __tstate = wxPyBeginAllowThreads();
31286 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31287
31288 wxPyEndAllowThreads(__tstate);
31289 if (PyErr_Occurred()) SWIG_fail;
31290 }
31291 resultobj = SWIG_From_int((result));
31292 return resultobj;
31293 fail:
31294 return NULL;
31295 }
31296
31297
31298 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31299 PyObject *resultobj;
31300 wxWindow *arg1 = (wxWindow *) 0 ;
31301 wxPoint *arg2 = 0 ;
31302 wxHitTest result;
31303 wxPoint temp2 ;
31304 PyObject * obj0 = 0 ;
31305 PyObject * obj1 = 0 ;
31306 char *kwnames[] = {
31307 (char *) "self",(char *) "pt", NULL
31308 };
31309
31310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31312 if (SWIG_arg_fail(1)) SWIG_fail;
31313 {
31314 arg2 = &temp2;
31315 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31316 }
31317 {
31318 PyThreadState* __tstate = wxPyBeginAllowThreads();
31319 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31320
31321 wxPyEndAllowThreads(__tstate);
31322 if (PyErr_Occurred()) SWIG_fail;
31323 }
31324 resultobj = SWIG_From_int((result));
31325 return resultobj;
31326 fail:
31327 return NULL;
31328 }
31329
31330
31331 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31332 PyObject *resultobj;
31333 wxWindow *arg1 = (wxWindow *) 0 ;
31334 long arg2 ;
31335 wxBorder result;
31336 PyObject * obj0 = 0 ;
31337 PyObject * obj1 = 0 ;
31338
31339 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31341 if (SWIG_arg_fail(1)) SWIG_fail;
31342 {
31343 arg2 = (long)(SWIG_As_long(obj1));
31344 if (SWIG_arg_fail(2)) SWIG_fail;
31345 }
31346 {
31347 PyThreadState* __tstate = wxPyBeginAllowThreads();
31348 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31349
31350 wxPyEndAllowThreads(__tstate);
31351 if (PyErr_Occurred()) SWIG_fail;
31352 }
31353 resultobj = SWIG_From_int((result));
31354 return resultobj;
31355 fail:
31356 return NULL;
31357 }
31358
31359
31360 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31361 PyObject *resultobj;
31362 wxWindow *arg1 = (wxWindow *) 0 ;
31363 wxBorder result;
31364 PyObject * obj0 = 0 ;
31365
31366 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31368 if (SWIG_arg_fail(1)) SWIG_fail;
31369 {
31370 PyThreadState* __tstate = wxPyBeginAllowThreads();
31371 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31372
31373 wxPyEndAllowThreads(__tstate);
31374 if (PyErr_Occurred()) SWIG_fail;
31375 }
31376 resultobj = SWIG_From_int((result));
31377 return resultobj;
31378 fail:
31379 return NULL;
31380 }
31381
31382
31383 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31384 int argc;
31385 PyObject *argv[3];
31386 int ii;
31387
31388 argc = PyObject_Length(args);
31389 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31390 argv[ii] = PyTuple_GetItem(args,ii);
31391 }
31392 if (argc == 1) {
31393 int _v;
31394 {
31395 void *ptr;
31396 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31397 _v = 0;
31398 PyErr_Clear();
31399 } else {
31400 _v = 1;
31401 }
31402 }
31403 if (_v) {
31404 return _wrap_Window_GetBorder__SWIG_1(self,args);
31405 }
31406 }
31407 if (argc == 2) {
31408 int _v;
31409 {
31410 void *ptr;
31411 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31412 _v = 0;
31413 PyErr_Clear();
31414 } else {
31415 _v = 1;
31416 }
31417 }
31418 if (_v) {
31419 _v = SWIG_Check_long(argv[1]);
31420 if (_v) {
31421 return _wrap_Window_GetBorder__SWIG_0(self,args);
31422 }
31423 }
31424 }
31425
31426 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31427 return NULL;
31428 }
31429
31430
31431 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31432 PyObject *resultobj;
31433 wxWindow *arg1 = (wxWindow *) 0 ;
31434 long arg2 = (long) wxUPDATE_UI_NONE ;
31435 PyObject * obj0 = 0 ;
31436 PyObject * obj1 = 0 ;
31437 char *kwnames[] = {
31438 (char *) "self",(char *) "flags", NULL
31439 };
31440
31441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31443 if (SWIG_arg_fail(1)) SWIG_fail;
31444 if (obj1) {
31445 {
31446 arg2 = (long)(SWIG_As_long(obj1));
31447 if (SWIG_arg_fail(2)) SWIG_fail;
31448 }
31449 }
31450 {
31451 PyThreadState* __tstate = wxPyBeginAllowThreads();
31452 (arg1)->UpdateWindowUI(arg2);
31453
31454 wxPyEndAllowThreads(__tstate);
31455 if (PyErr_Occurred()) SWIG_fail;
31456 }
31457 Py_INCREF(Py_None); resultobj = Py_None;
31458 return resultobj;
31459 fail:
31460 return NULL;
31461 }
31462
31463
31464 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31465 PyObject *resultobj;
31466 wxWindow *arg1 = (wxWindow *) 0 ;
31467 wxMenu *arg2 = (wxMenu *) 0 ;
31468 int arg3 = (int) -1 ;
31469 int arg4 = (int) -1 ;
31470 bool result;
31471 PyObject * obj0 = 0 ;
31472 PyObject * obj1 = 0 ;
31473 PyObject * obj2 = 0 ;
31474 PyObject * obj3 = 0 ;
31475 char *kwnames[] = {
31476 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31477 };
31478
31479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31481 if (SWIG_arg_fail(1)) SWIG_fail;
31482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31483 if (SWIG_arg_fail(2)) SWIG_fail;
31484 if (obj2) {
31485 {
31486 arg3 = (int)(SWIG_As_int(obj2));
31487 if (SWIG_arg_fail(3)) SWIG_fail;
31488 }
31489 }
31490 if (obj3) {
31491 {
31492 arg4 = (int)(SWIG_As_int(obj3));
31493 if (SWIG_arg_fail(4)) SWIG_fail;
31494 }
31495 }
31496 {
31497 PyThreadState* __tstate = wxPyBeginAllowThreads();
31498 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31499
31500 wxPyEndAllowThreads(__tstate);
31501 if (PyErr_Occurred()) SWIG_fail;
31502 }
31503 {
31504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31505 }
31506 return resultobj;
31507 fail:
31508 return NULL;
31509 }
31510
31511
31512 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31513 PyObject *resultobj;
31514 wxWindow *arg1 = (wxWindow *) 0 ;
31515 wxMenu *arg2 = (wxMenu *) 0 ;
31516 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31517 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31518 bool result;
31519 wxPoint temp3 ;
31520 PyObject * obj0 = 0 ;
31521 PyObject * obj1 = 0 ;
31522 PyObject * obj2 = 0 ;
31523 char *kwnames[] = {
31524 (char *) "self",(char *) "menu",(char *) "pos", NULL
31525 };
31526
31527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31529 if (SWIG_arg_fail(1)) SWIG_fail;
31530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31531 if (SWIG_arg_fail(2)) SWIG_fail;
31532 if (obj2) {
31533 {
31534 arg3 = &temp3;
31535 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31536 }
31537 }
31538 {
31539 PyThreadState* __tstate = wxPyBeginAllowThreads();
31540 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31541
31542 wxPyEndAllowThreads(__tstate);
31543 if (PyErr_Occurred()) SWIG_fail;
31544 }
31545 {
31546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31547 }
31548 return resultobj;
31549 fail:
31550 return NULL;
31551 }
31552
31553
31554 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31555 PyObject *resultobj;
31556 wxWindow *arg1 = (wxWindow *) 0 ;
31557 long result;
31558 PyObject * obj0 = 0 ;
31559 char *kwnames[] = {
31560 (char *) "self", NULL
31561 };
31562
31563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31565 if (SWIG_arg_fail(1)) SWIG_fail;
31566 {
31567 PyThreadState* __tstate = wxPyBeginAllowThreads();
31568 result = (long)wxWindow_GetHandle(arg1);
31569
31570 wxPyEndAllowThreads(__tstate);
31571 if (PyErr_Occurred()) SWIG_fail;
31572 }
31573 {
31574 resultobj = SWIG_From_long((long)(result));
31575 }
31576 return resultobj;
31577 fail:
31578 return NULL;
31579 }
31580
31581
31582 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31583 PyObject *resultobj;
31584 wxWindow *arg1 = (wxWindow *) 0 ;
31585 long arg2 ;
31586 PyObject * obj0 = 0 ;
31587 PyObject * obj1 = 0 ;
31588 char *kwnames[] = {
31589 (char *) "self",(char *) "handle", NULL
31590 };
31591
31592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31594 if (SWIG_arg_fail(1)) SWIG_fail;
31595 {
31596 arg2 = (long)(SWIG_As_long(obj1));
31597 if (SWIG_arg_fail(2)) SWIG_fail;
31598 }
31599 {
31600 PyThreadState* __tstate = wxPyBeginAllowThreads();
31601 wxWindow_AssociateHandle(arg1,arg2);
31602
31603 wxPyEndAllowThreads(__tstate);
31604 if (PyErr_Occurred()) SWIG_fail;
31605 }
31606 Py_INCREF(Py_None); resultobj = Py_None;
31607 return resultobj;
31608 fail:
31609 return NULL;
31610 }
31611
31612
31613 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31614 PyObject *resultobj;
31615 wxWindow *arg1 = (wxWindow *) 0 ;
31616 PyObject * obj0 = 0 ;
31617 char *kwnames[] = {
31618 (char *) "self", NULL
31619 };
31620
31621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31623 if (SWIG_arg_fail(1)) SWIG_fail;
31624 {
31625 PyThreadState* __tstate = wxPyBeginAllowThreads();
31626 (arg1)->DissociateHandle();
31627
31628 wxPyEndAllowThreads(__tstate);
31629 if (PyErr_Occurred()) SWIG_fail;
31630 }
31631 Py_INCREF(Py_None); resultobj = Py_None;
31632 return resultobj;
31633 fail:
31634 return NULL;
31635 }
31636
31637
31638 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31639 PyObject *resultobj;
31640 wxWindow *arg1 = (wxWindow *) 0 ;
31641 int arg2 ;
31642 bool result;
31643 PyObject * obj0 = 0 ;
31644 PyObject * obj1 = 0 ;
31645 char *kwnames[] = {
31646 (char *) "self",(char *) "orient", NULL
31647 };
31648
31649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31651 if (SWIG_arg_fail(1)) SWIG_fail;
31652 {
31653 arg2 = (int)(SWIG_As_int(obj1));
31654 if (SWIG_arg_fail(2)) SWIG_fail;
31655 }
31656 {
31657 PyThreadState* __tstate = wxPyBeginAllowThreads();
31658 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31659
31660 wxPyEndAllowThreads(__tstate);
31661 if (PyErr_Occurred()) SWIG_fail;
31662 }
31663 {
31664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31665 }
31666 return resultobj;
31667 fail:
31668 return NULL;
31669 }
31670
31671
31672 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31673 PyObject *resultobj;
31674 wxWindow *arg1 = (wxWindow *) 0 ;
31675 int arg2 ;
31676 int arg3 ;
31677 int arg4 ;
31678 int arg5 ;
31679 bool arg6 = (bool) true ;
31680 PyObject * obj0 = 0 ;
31681 PyObject * obj1 = 0 ;
31682 PyObject * obj2 = 0 ;
31683 PyObject * obj3 = 0 ;
31684 PyObject * obj4 = 0 ;
31685 PyObject * obj5 = 0 ;
31686 char *kwnames[] = {
31687 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31688 };
31689
31690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31692 if (SWIG_arg_fail(1)) SWIG_fail;
31693 {
31694 arg2 = (int)(SWIG_As_int(obj1));
31695 if (SWIG_arg_fail(2)) SWIG_fail;
31696 }
31697 {
31698 arg3 = (int)(SWIG_As_int(obj2));
31699 if (SWIG_arg_fail(3)) SWIG_fail;
31700 }
31701 {
31702 arg4 = (int)(SWIG_As_int(obj3));
31703 if (SWIG_arg_fail(4)) SWIG_fail;
31704 }
31705 {
31706 arg5 = (int)(SWIG_As_int(obj4));
31707 if (SWIG_arg_fail(5)) SWIG_fail;
31708 }
31709 if (obj5) {
31710 {
31711 arg6 = (bool)(SWIG_As_bool(obj5));
31712 if (SWIG_arg_fail(6)) SWIG_fail;
31713 }
31714 }
31715 {
31716 PyThreadState* __tstate = wxPyBeginAllowThreads();
31717 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31718
31719 wxPyEndAllowThreads(__tstate);
31720 if (PyErr_Occurred()) SWIG_fail;
31721 }
31722 Py_INCREF(Py_None); resultobj = Py_None;
31723 return resultobj;
31724 fail:
31725 return NULL;
31726 }
31727
31728
31729 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31730 PyObject *resultobj;
31731 wxWindow *arg1 = (wxWindow *) 0 ;
31732 int arg2 ;
31733 int arg3 ;
31734 bool arg4 = (bool) true ;
31735 PyObject * obj0 = 0 ;
31736 PyObject * obj1 = 0 ;
31737 PyObject * obj2 = 0 ;
31738 PyObject * obj3 = 0 ;
31739 char *kwnames[] = {
31740 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31741 };
31742
31743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31745 if (SWIG_arg_fail(1)) SWIG_fail;
31746 {
31747 arg2 = (int)(SWIG_As_int(obj1));
31748 if (SWIG_arg_fail(2)) SWIG_fail;
31749 }
31750 {
31751 arg3 = (int)(SWIG_As_int(obj2));
31752 if (SWIG_arg_fail(3)) SWIG_fail;
31753 }
31754 if (obj3) {
31755 {
31756 arg4 = (bool)(SWIG_As_bool(obj3));
31757 if (SWIG_arg_fail(4)) SWIG_fail;
31758 }
31759 }
31760 {
31761 PyThreadState* __tstate = wxPyBeginAllowThreads();
31762 (arg1)->SetScrollPos(arg2,arg3,arg4);
31763
31764 wxPyEndAllowThreads(__tstate);
31765 if (PyErr_Occurred()) SWIG_fail;
31766 }
31767 Py_INCREF(Py_None); resultobj = Py_None;
31768 return resultobj;
31769 fail:
31770 return NULL;
31771 }
31772
31773
31774 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31775 PyObject *resultobj;
31776 wxWindow *arg1 = (wxWindow *) 0 ;
31777 int arg2 ;
31778 int result;
31779 PyObject * obj0 = 0 ;
31780 PyObject * obj1 = 0 ;
31781 char *kwnames[] = {
31782 (char *) "self",(char *) "orientation", NULL
31783 };
31784
31785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31787 if (SWIG_arg_fail(1)) SWIG_fail;
31788 {
31789 arg2 = (int)(SWIG_As_int(obj1));
31790 if (SWIG_arg_fail(2)) SWIG_fail;
31791 }
31792 {
31793 PyThreadState* __tstate = wxPyBeginAllowThreads();
31794 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31795
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 {
31800 resultobj = SWIG_From_int((int)(result));
31801 }
31802 return resultobj;
31803 fail:
31804 return NULL;
31805 }
31806
31807
31808 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31809 PyObject *resultobj;
31810 wxWindow *arg1 = (wxWindow *) 0 ;
31811 int arg2 ;
31812 int result;
31813 PyObject * obj0 = 0 ;
31814 PyObject * obj1 = 0 ;
31815 char *kwnames[] = {
31816 (char *) "self",(char *) "orientation", NULL
31817 };
31818
31819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31821 if (SWIG_arg_fail(1)) SWIG_fail;
31822 {
31823 arg2 = (int)(SWIG_As_int(obj1));
31824 if (SWIG_arg_fail(2)) SWIG_fail;
31825 }
31826 {
31827 PyThreadState* __tstate = wxPyBeginAllowThreads();
31828 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31829
31830 wxPyEndAllowThreads(__tstate);
31831 if (PyErr_Occurred()) SWIG_fail;
31832 }
31833 {
31834 resultobj = SWIG_From_int((int)(result));
31835 }
31836 return resultobj;
31837 fail:
31838 return NULL;
31839 }
31840
31841
31842 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31843 PyObject *resultobj;
31844 wxWindow *arg1 = (wxWindow *) 0 ;
31845 int arg2 ;
31846 int result;
31847 PyObject * obj0 = 0 ;
31848 PyObject * obj1 = 0 ;
31849 char *kwnames[] = {
31850 (char *) "self",(char *) "orientation", NULL
31851 };
31852
31853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31855 if (SWIG_arg_fail(1)) SWIG_fail;
31856 {
31857 arg2 = (int)(SWIG_As_int(obj1));
31858 if (SWIG_arg_fail(2)) SWIG_fail;
31859 }
31860 {
31861 PyThreadState* __tstate = wxPyBeginAllowThreads();
31862 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31863
31864 wxPyEndAllowThreads(__tstate);
31865 if (PyErr_Occurred()) SWIG_fail;
31866 }
31867 {
31868 resultobj = SWIG_From_int((int)(result));
31869 }
31870 return resultobj;
31871 fail:
31872 return NULL;
31873 }
31874
31875
31876 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31877 PyObject *resultobj;
31878 wxWindow *arg1 = (wxWindow *) 0 ;
31879 int arg2 ;
31880 int arg3 ;
31881 wxRect *arg4 = (wxRect *) NULL ;
31882 PyObject * obj0 = 0 ;
31883 PyObject * obj1 = 0 ;
31884 PyObject * obj2 = 0 ;
31885 PyObject * obj3 = 0 ;
31886 char *kwnames[] = {
31887 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31888 };
31889
31890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31892 if (SWIG_arg_fail(1)) SWIG_fail;
31893 {
31894 arg2 = (int)(SWIG_As_int(obj1));
31895 if (SWIG_arg_fail(2)) SWIG_fail;
31896 }
31897 {
31898 arg3 = (int)(SWIG_As_int(obj2));
31899 if (SWIG_arg_fail(3)) SWIG_fail;
31900 }
31901 if (obj3) {
31902 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31903 if (SWIG_arg_fail(4)) SWIG_fail;
31904 }
31905 {
31906 PyThreadState* __tstate = wxPyBeginAllowThreads();
31907 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31908
31909 wxPyEndAllowThreads(__tstate);
31910 if (PyErr_Occurred()) SWIG_fail;
31911 }
31912 Py_INCREF(Py_None); resultobj = Py_None;
31913 return resultobj;
31914 fail:
31915 return NULL;
31916 }
31917
31918
31919 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31920 PyObject *resultobj;
31921 wxWindow *arg1 = (wxWindow *) 0 ;
31922 int arg2 ;
31923 bool result;
31924 PyObject * obj0 = 0 ;
31925 PyObject * obj1 = 0 ;
31926 char *kwnames[] = {
31927 (char *) "self",(char *) "lines", NULL
31928 };
31929
31930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31932 if (SWIG_arg_fail(1)) SWIG_fail;
31933 {
31934 arg2 = (int)(SWIG_As_int(obj1));
31935 if (SWIG_arg_fail(2)) SWIG_fail;
31936 }
31937 {
31938 PyThreadState* __tstate = wxPyBeginAllowThreads();
31939 result = (bool)(arg1)->ScrollLines(arg2);
31940
31941 wxPyEndAllowThreads(__tstate);
31942 if (PyErr_Occurred()) SWIG_fail;
31943 }
31944 {
31945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31946 }
31947 return resultobj;
31948 fail:
31949 return NULL;
31950 }
31951
31952
31953 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31954 PyObject *resultobj;
31955 wxWindow *arg1 = (wxWindow *) 0 ;
31956 int arg2 ;
31957 bool result;
31958 PyObject * obj0 = 0 ;
31959 PyObject * obj1 = 0 ;
31960 char *kwnames[] = {
31961 (char *) "self",(char *) "pages", NULL
31962 };
31963
31964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31966 if (SWIG_arg_fail(1)) SWIG_fail;
31967 {
31968 arg2 = (int)(SWIG_As_int(obj1));
31969 if (SWIG_arg_fail(2)) SWIG_fail;
31970 }
31971 {
31972 PyThreadState* __tstate = wxPyBeginAllowThreads();
31973 result = (bool)(arg1)->ScrollPages(arg2);
31974
31975 wxPyEndAllowThreads(__tstate);
31976 if (PyErr_Occurred()) SWIG_fail;
31977 }
31978 {
31979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31980 }
31981 return resultobj;
31982 fail:
31983 return NULL;
31984 }
31985
31986
31987 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31988 PyObject *resultobj;
31989 wxWindow *arg1 = (wxWindow *) 0 ;
31990 bool result;
31991 PyObject * obj0 = 0 ;
31992 char *kwnames[] = {
31993 (char *) "self", NULL
31994 };
31995
31996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31998 if (SWIG_arg_fail(1)) SWIG_fail;
31999 {
32000 PyThreadState* __tstate = wxPyBeginAllowThreads();
32001 result = (bool)(arg1)->LineUp();
32002
32003 wxPyEndAllowThreads(__tstate);
32004 if (PyErr_Occurred()) SWIG_fail;
32005 }
32006 {
32007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32008 }
32009 return resultobj;
32010 fail:
32011 return NULL;
32012 }
32013
32014
32015 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
32016 PyObject *resultobj;
32017 wxWindow *arg1 = (wxWindow *) 0 ;
32018 bool result;
32019 PyObject * obj0 = 0 ;
32020 char *kwnames[] = {
32021 (char *) "self", NULL
32022 };
32023
32024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
32025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32026 if (SWIG_arg_fail(1)) SWIG_fail;
32027 {
32028 PyThreadState* __tstate = wxPyBeginAllowThreads();
32029 result = (bool)(arg1)->LineDown();
32030
32031 wxPyEndAllowThreads(__tstate);
32032 if (PyErr_Occurred()) SWIG_fail;
32033 }
32034 {
32035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32036 }
32037 return resultobj;
32038 fail:
32039 return NULL;
32040 }
32041
32042
32043 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
32044 PyObject *resultobj;
32045 wxWindow *arg1 = (wxWindow *) 0 ;
32046 bool result;
32047 PyObject * obj0 = 0 ;
32048 char *kwnames[] = {
32049 (char *) "self", NULL
32050 };
32051
32052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
32053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32054 if (SWIG_arg_fail(1)) SWIG_fail;
32055 {
32056 PyThreadState* __tstate = wxPyBeginAllowThreads();
32057 result = (bool)(arg1)->PageUp();
32058
32059 wxPyEndAllowThreads(__tstate);
32060 if (PyErr_Occurred()) SWIG_fail;
32061 }
32062 {
32063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32064 }
32065 return resultobj;
32066 fail:
32067 return NULL;
32068 }
32069
32070
32071 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32072 PyObject *resultobj;
32073 wxWindow *arg1 = (wxWindow *) 0 ;
32074 bool result;
32075 PyObject * obj0 = 0 ;
32076 char *kwnames[] = {
32077 (char *) "self", NULL
32078 };
32079
32080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32082 if (SWIG_arg_fail(1)) SWIG_fail;
32083 {
32084 PyThreadState* __tstate = wxPyBeginAllowThreads();
32085 result = (bool)(arg1)->PageDown();
32086
32087 wxPyEndAllowThreads(__tstate);
32088 if (PyErr_Occurred()) SWIG_fail;
32089 }
32090 {
32091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32092 }
32093 return resultobj;
32094 fail:
32095 return NULL;
32096 }
32097
32098
32099 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32100 PyObject *resultobj;
32101 wxWindow *arg1 = (wxWindow *) 0 ;
32102 wxString *arg2 = 0 ;
32103 bool temp2 = false ;
32104 PyObject * obj0 = 0 ;
32105 PyObject * obj1 = 0 ;
32106 char *kwnames[] = {
32107 (char *) "self",(char *) "text", NULL
32108 };
32109
32110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32112 if (SWIG_arg_fail(1)) SWIG_fail;
32113 {
32114 arg2 = wxString_in_helper(obj1);
32115 if (arg2 == NULL) SWIG_fail;
32116 temp2 = true;
32117 }
32118 {
32119 PyThreadState* __tstate = wxPyBeginAllowThreads();
32120 (arg1)->SetHelpText((wxString const &)*arg2);
32121
32122 wxPyEndAllowThreads(__tstate);
32123 if (PyErr_Occurred()) SWIG_fail;
32124 }
32125 Py_INCREF(Py_None); resultobj = Py_None;
32126 {
32127 if (temp2)
32128 delete arg2;
32129 }
32130 return resultobj;
32131 fail:
32132 {
32133 if (temp2)
32134 delete arg2;
32135 }
32136 return NULL;
32137 }
32138
32139
32140 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32141 PyObject *resultobj;
32142 wxWindow *arg1 = (wxWindow *) 0 ;
32143 wxString *arg2 = 0 ;
32144 bool temp2 = false ;
32145 PyObject * obj0 = 0 ;
32146 PyObject * obj1 = 0 ;
32147 char *kwnames[] = {
32148 (char *) "self",(char *) "text", NULL
32149 };
32150
32151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32153 if (SWIG_arg_fail(1)) SWIG_fail;
32154 {
32155 arg2 = wxString_in_helper(obj1);
32156 if (arg2 == NULL) SWIG_fail;
32157 temp2 = true;
32158 }
32159 {
32160 PyThreadState* __tstate = wxPyBeginAllowThreads();
32161 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32162
32163 wxPyEndAllowThreads(__tstate);
32164 if (PyErr_Occurred()) SWIG_fail;
32165 }
32166 Py_INCREF(Py_None); resultobj = Py_None;
32167 {
32168 if (temp2)
32169 delete arg2;
32170 }
32171 return resultobj;
32172 fail:
32173 {
32174 if (temp2)
32175 delete arg2;
32176 }
32177 return NULL;
32178 }
32179
32180
32181 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32182 PyObject *resultobj;
32183 wxWindow *arg1 = (wxWindow *) 0 ;
32184 wxString result;
32185 PyObject * obj0 = 0 ;
32186 char *kwnames[] = {
32187 (char *) "self", NULL
32188 };
32189
32190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32192 if (SWIG_arg_fail(1)) SWIG_fail;
32193 {
32194 PyThreadState* __tstate = wxPyBeginAllowThreads();
32195 result = ((wxWindow const *)arg1)->GetHelpText();
32196
32197 wxPyEndAllowThreads(__tstate);
32198 if (PyErr_Occurred()) SWIG_fail;
32199 }
32200 {
32201 #if wxUSE_UNICODE
32202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32203 #else
32204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32205 #endif
32206 }
32207 return resultobj;
32208 fail:
32209 return NULL;
32210 }
32211
32212
32213 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32214 PyObject *resultobj;
32215 wxWindow *arg1 = (wxWindow *) 0 ;
32216 wxString *arg2 = 0 ;
32217 bool temp2 = false ;
32218 PyObject * obj0 = 0 ;
32219 PyObject * obj1 = 0 ;
32220 char *kwnames[] = {
32221 (char *) "self",(char *) "tip", NULL
32222 };
32223
32224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32226 if (SWIG_arg_fail(1)) SWIG_fail;
32227 {
32228 arg2 = wxString_in_helper(obj1);
32229 if (arg2 == NULL) SWIG_fail;
32230 temp2 = true;
32231 }
32232 {
32233 PyThreadState* __tstate = wxPyBeginAllowThreads();
32234 (arg1)->SetToolTip((wxString const &)*arg2);
32235
32236 wxPyEndAllowThreads(__tstate);
32237 if (PyErr_Occurred()) SWIG_fail;
32238 }
32239 Py_INCREF(Py_None); resultobj = Py_None;
32240 {
32241 if (temp2)
32242 delete arg2;
32243 }
32244 return resultobj;
32245 fail:
32246 {
32247 if (temp2)
32248 delete arg2;
32249 }
32250 return NULL;
32251 }
32252
32253
32254 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32255 PyObject *resultobj;
32256 wxWindow *arg1 = (wxWindow *) 0 ;
32257 wxToolTip *arg2 = (wxToolTip *) 0 ;
32258 PyObject * obj0 = 0 ;
32259 PyObject * obj1 = 0 ;
32260 char *kwnames[] = {
32261 (char *) "self",(char *) "tip", NULL
32262 };
32263
32264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32266 if (SWIG_arg_fail(1)) SWIG_fail;
32267 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
32268 if (SWIG_arg_fail(2)) SWIG_fail;
32269 {
32270 PyThreadState* __tstate = wxPyBeginAllowThreads();
32271 (arg1)->SetToolTip(arg2);
32272
32273 wxPyEndAllowThreads(__tstate);
32274 if (PyErr_Occurred()) SWIG_fail;
32275 }
32276 Py_INCREF(Py_None); resultobj = Py_None;
32277 return resultobj;
32278 fail:
32279 return NULL;
32280 }
32281
32282
32283 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32284 PyObject *resultobj;
32285 wxWindow *arg1 = (wxWindow *) 0 ;
32286 wxToolTip *result;
32287 PyObject * obj0 = 0 ;
32288 char *kwnames[] = {
32289 (char *) "self", NULL
32290 };
32291
32292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32294 if (SWIG_arg_fail(1)) SWIG_fail;
32295 {
32296 PyThreadState* __tstate = wxPyBeginAllowThreads();
32297 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32298
32299 wxPyEndAllowThreads(__tstate);
32300 if (PyErr_Occurred()) SWIG_fail;
32301 }
32302 {
32303 resultobj = wxPyMake_wxObject(result, 0);
32304 }
32305 return resultobj;
32306 fail:
32307 return NULL;
32308 }
32309
32310
32311 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32312 PyObject *resultobj;
32313 wxWindow *arg1 = (wxWindow *) 0 ;
32314 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32315 PyObject * obj0 = 0 ;
32316 PyObject * obj1 = 0 ;
32317 char *kwnames[] = {
32318 (char *) "self",(char *) "dropTarget", NULL
32319 };
32320
32321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32323 if (SWIG_arg_fail(1)) SWIG_fail;
32324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32325 if (SWIG_arg_fail(2)) SWIG_fail;
32326 {
32327 PyThreadState* __tstate = wxPyBeginAllowThreads();
32328 (arg1)->SetDropTarget(arg2);
32329
32330 wxPyEndAllowThreads(__tstate);
32331 if (PyErr_Occurred()) SWIG_fail;
32332 }
32333 Py_INCREF(Py_None); resultobj = Py_None;
32334 return resultobj;
32335 fail:
32336 return NULL;
32337 }
32338
32339
32340 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32341 PyObject *resultobj;
32342 wxWindow *arg1 = (wxWindow *) 0 ;
32343 wxPyDropTarget *result;
32344 PyObject * obj0 = 0 ;
32345 char *kwnames[] = {
32346 (char *) "self", NULL
32347 };
32348
32349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32351 if (SWIG_arg_fail(1)) SWIG_fail;
32352 {
32353 PyThreadState* __tstate = wxPyBeginAllowThreads();
32354 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32355
32356 wxPyEndAllowThreads(__tstate);
32357 if (PyErr_Occurred()) SWIG_fail;
32358 }
32359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32360 return resultobj;
32361 fail:
32362 return NULL;
32363 }
32364
32365
32366 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32367 PyObject *resultobj;
32368 wxWindow *arg1 = (wxWindow *) 0 ;
32369 bool arg2 ;
32370 PyObject * obj0 = 0 ;
32371 PyObject * obj1 = 0 ;
32372 char *kwnames[] = {
32373 (char *) "self",(char *) "accept", NULL
32374 };
32375
32376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32378 if (SWIG_arg_fail(1)) SWIG_fail;
32379 {
32380 arg2 = (bool)(SWIG_As_bool(obj1));
32381 if (SWIG_arg_fail(2)) SWIG_fail;
32382 }
32383 {
32384 PyThreadState* __tstate = wxPyBeginAllowThreads();
32385 wxWindow_DragAcceptFiles(arg1,arg2);
32386
32387 wxPyEndAllowThreads(__tstate);
32388 if (PyErr_Occurred()) SWIG_fail;
32389 }
32390 Py_INCREF(Py_None); resultobj = Py_None;
32391 return resultobj;
32392 fail:
32393 return NULL;
32394 }
32395
32396
32397 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32398 PyObject *resultobj;
32399 wxWindow *arg1 = (wxWindow *) 0 ;
32400 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32401 PyObject * obj0 = 0 ;
32402 PyObject * obj1 = 0 ;
32403 char *kwnames[] = {
32404 (char *) "self",(char *) "constraints", NULL
32405 };
32406
32407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32409 if (SWIG_arg_fail(1)) SWIG_fail;
32410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32411 if (SWIG_arg_fail(2)) SWIG_fail;
32412 {
32413 PyThreadState* __tstate = wxPyBeginAllowThreads();
32414 (arg1)->SetConstraints(arg2);
32415
32416 wxPyEndAllowThreads(__tstate);
32417 if (PyErr_Occurred()) SWIG_fail;
32418 }
32419 Py_INCREF(Py_None); resultobj = Py_None;
32420 return resultobj;
32421 fail:
32422 return NULL;
32423 }
32424
32425
32426 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32427 PyObject *resultobj;
32428 wxWindow *arg1 = (wxWindow *) 0 ;
32429 wxLayoutConstraints *result;
32430 PyObject * obj0 = 0 ;
32431 char *kwnames[] = {
32432 (char *) "self", NULL
32433 };
32434
32435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32437 if (SWIG_arg_fail(1)) SWIG_fail;
32438 {
32439 PyThreadState* __tstate = wxPyBeginAllowThreads();
32440 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32441
32442 wxPyEndAllowThreads(__tstate);
32443 if (PyErr_Occurred()) SWIG_fail;
32444 }
32445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32446 return resultobj;
32447 fail:
32448 return NULL;
32449 }
32450
32451
32452 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32453 PyObject *resultobj;
32454 wxWindow *arg1 = (wxWindow *) 0 ;
32455 bool arg2 ;
32456 PyObject * obj0 = 0 ;
32457 PyObject * obj1 = 0 ;
32458 char *kwnames[] = {
32459 (char *) "self",(char *) "autoLayout", NULL
32460 };
32461
32462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32464 if (SWIG_arg_fail(1)) SWIG_fail;
32465 {
32466 arg2 = (bool)(SWIG_As_bool(obj1));
32467 if (SWIG_arg_fail(2)) SWIG_fail;
32468 }
32469 {
32470 PyThreadState* __tstate = wxPyBeginAllowThreads();
32471 (arg1)->SetAutoLayout(arg2);
32472
32473 wxPyEndAllowThreads(__tstate);
32474 if (PyErr_Occurred()) SWIG_fail;
32475 }
32476 Py_INCREF(Py_None); resultobj = Py_None;
32477 return resultobj;
32478 fail:
32479 return NULL;
32480 }
32481
32482
32483 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32484 PyObject *resultobj;
32485 wxWindow *arg1 = (wxWindow *) 0 ;
32486 bool result;
32487 PyObject * obj0 = 0 ;
32488 char *kwnames[] = {
32489 (char *) "self", NULL
32490 };
32491
32492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32494 if (SWIG_arg_fail(1)) SWIG_fail;
32495 {
32496 PyThreadState* __tstate = wxPyBeginAllowThreads();
32497 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32498
32499 wxPyEndAllowThreads(__tstate);
32500 if (PyErr_Occurred()) SWIG_fail;
32501 }
32502 {
32503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32504 }
32505 return resultobj;
32506 fail:
32507 return NULL;
32508 }
32509
32510
32511 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32512 PyObject *resultobj;
32513 wxWindow *arg1 = (wxWindow *) 0 ;
32514 bool result;
32515 PyObject * obj0 = 0 ;
32516 char *kwnames[] = {
32517 (char *) "self", NULL
32518 };
32519
32520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32522 if (SWIG_arg_fail(1)) SWIG_fail;
32523 {
32524 PyThreadState* __tstate = wxPyBeginAllowThreads();
32525 result = (bool)(arg1)->Layout();
32526
32527 wxPyEndAllowThreads(__tstate);
32528 if (PyErr_Occurred()) SWIG_fail;
32529 }
32530 {
32531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32532 }
32533 return resultobj;
32534 fail:
32535 return NULL;
32536 }
32537
32538
32539 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32540 PyObject *resultobj;
32541 wxWindow *arg1 = (wxWindow *) 0 ;
32542 wxSizer *arg2 = (wxSizer *) 0 ;
32543 bool arg3 = (bool) true ;
32544 PyObject * obj0 = 0 ;
32545 PyObject * obj1 = 0 ;
32546 PyObject * obj2 = 0 ;
32547 char *kwnames[] = {
32548 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32549 };
32550
32551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32553 if (SWIG_arg_fail(1)) SWIG_fail;
32554 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32555 if (SWIG_arg_fail(2)) SWIG_fail;
32556 if (obj2) {
32557 {
32558 arg3 = (bool)(SWIG_As_bool(obj2));
32559 if (SWIG_arg_fail(3)) SWIG_fail;
32560 }
32561 }
32562 {
32563 PyThreadState* __tstate = wxPyBeginAllowThreads();
32564 (arg1)->SetSizer(arg2,arg3);
32565
32566 wxPyEndAllowThreads(__tstate);
32567 if (PyErr_Occurred()) SWIG_fail;
32568 }
32569 Py_INCREF(Py_None); resultobj = Py_None;
32570 return resultobj;
32571 fail:
32572 return NULL;
32573 }
32574
32575
32576 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32577 PyObject *resultobj;
32578 wxWindow *arg1 = (wxWindow *) 0 ;
32579 wxSizer *arg2 = (wxSizer *) 0 ;
32580 bool arg3 = (bool) true ;
32581 PyObject * obj0 = 0 ;
32582 PyObject * obj1 = 0 ;
32583 PyObject * obj2 = 0 ;
32584 char *kwnames[] = {
32585 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32586 };
32587
32588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32590 if (SWIG_arg_fail(1)) SWIG_fail;
32591 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32592 if (SWIG_arg_fail(2)) SWIG_fail;
32593 if (obj2) {
32594 {
32595 arg3 = (bool)(SWIG_As_bool(obj2));
32596 if (SWIG_arg_fail(3)) SWIG_fail;
32597 }
32598 }
32599 {
32600 PyThreadState* __tstate = wxPyBeginAllowThreads();
32601 (arg1)->SetSizerAndFit(arg2,arg3);
32602
32603 wxPyEndAllowThreads(__tstate);
32604 if (PyErr_Occurred()) SWIG_fail;
32605 }
32606 Py_INCREF(Py_None); resultobj = Py_None;
32607 return resultobj;
32608 fail:
32609 return NULL;
32610 }
32611
32612
32613 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32614 PyObject *resultobj;
32615 wxWindow *arg1 = (wxWindow *) 0 ;
32616 wxSizer *result;
32617 PyObject * obj0 = 0 ;
32618 char *kwnames[] = {
32619 (char *) "self", NULL
32620 };
32621
32622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32624 if (SWIG_arg_fail(1)) SWIG_fail;
32625 {
32626 PyThreadState* __tstate = wxPyBeginAllowThreads();
32627 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32628
32629 wxPyEndAllowThreads(__tstate);
32630 if (PyErr_Occurred()) SWIG_fail;
32631 }
32632 {
32633 resultobj = wxPyMake_wxObject(result, 0);
32634 }
32635 return resultobj;
32636 fail:
32637 return NULL;
32638 }
32639
32640
32641 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32642 PyObject *resultobj;
32643 wxWindow *arg1 = (wxWindow *) 0 ;
32644 wxSizer *arg2 = (wxSizer *) 0 ;
32645 PyObject * obj0 = 0 ;
32646 PyObject * obj1 = 0 ;
32647 char *kwnames[] = {
32648 (char *) "self",(char *) "sizer", NULL
32649 };
32650
32651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32653 if (SWIG_arg_fail(1)) SWIG_fail;
32654 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32655 if (SWIG_arg_fail(2)) SWIG_fail;
32656 {
32657 PyThreadState* __tstate = wxPyBeginAllowThreads();
32658 (arg1)->SetContainingSizer(arg2);
32659
32660 wxPyEndAllowThreads(__tstate);
32661 if (PyErr_Occurred()) SWIG_fail;
32662 }
32663 Py_INCREF(Py_None); resultobj = Py_None;
32664 return resultobj;
32665 fail:
32666 return NULL;
32667 }
32668
32669
32670 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32671 PyObject *resultobj;
32672 wxWindow *arg1 = (wxWindow *) 0 ;
32673 wxSizer *result;
32674 PyObject * obj0 = 0 ;
32675 char *kwnames[] = {
32676 (char *) "self", NULL
32677 };
32678
32679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32681 if (SWIG_arg_fail(1)) SWIG_fail;
32682 {
32683 PyThreadState* __tstate = wxPyBeginAllowThreads();
32684 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32685
32686 wxPyEndAllowThreads(__tstate);
32687 if (PyErr_Occurred()) SWIG_fail;
32688 }
32689 {
32690 resultobj = wxPyMake_wxObject(result, 0);
32691 }
32692 return resultobj;
32693 fail:
32694 return NULL;
32695 }
32696
32697
32698 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32699 PyObject *resultobj;
32700 wxWindow *arg1 = (wxWindow *) 0 ;
32701 PyObject * obj0 = 0 ;
32702 char *kwnames[] = {
32703 (char *) "self", NULL
32704 };
32705
32706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32708 if (SWIG_arg_fail(1)) SWIG_fail;
32709 {
32710 PyThreadState* __tstate = wxPyBeginAllowThreads();
32711 (arg1)->InheritAttributes();
32712
32713 wxPyEndAllowThreads(__tstate);
32714 if (PyErr_Occurred()) SWIG_fail;
32715 }
32716 Py_INCREF(Py_None); resultobj = Py_None;
32717 return resultobj;
32718 fail:
32719 return NULL;
32720 }
32721
32722
32723 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32724 PyObject *resultobj;
32725 wxWindow *arg1 = (wxWindow *) 0 ;
32726 bool result;
32727 PyObject * obj0 = 0 ;
32728 char *kwnames[] = {
32729 (char *) "self", NULL
32730 };
32731
32732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32734 if (SWIG_arg_fail(1)) SWIG_fail;
32735 {
32736 PyThreadState* __tstate = wxPyBeginAllowThreads();
32737 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32738
32739 wxPyEndAllowThreads(__tstate);
32740 if (PyErr_Occurred()) SWIG_fail;
32741 }
32742 {
32743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32744 }
32745 return resultobj;
32746 fail:
32747 return NULL;
32748 }
32749
32750
32751 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32752 PyObject *obj;
32753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32754 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32755 Py_INCREF(obj);
32756 return Py_BuildValue((char *)"");
32757 }
32758 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32759 PyObject *resultobj;
32760 long arg1 ;
32761 wxWindow *arg2 = (wxWindow *) NULL ;
32762 wxWindow *result;
32763 PyObject * obj0 = 0 ;
32764 PyObject * obj1 = 0 ;
32765 char *kwnames[] = {
32766 (char *) "id",(char *) "parent", NULL
32767 };
32768
32769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32770 {
32771 arg1 = (long)(SWIG_As_long(obj0));
32772 if (SWIG_arg_fail(1)) SWIG_fail;
32773 }
32774 if (obj1) {
32775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32776 if (SWIG_arg_fail(2)) SWIG_fail;
32777 }
32778 {
32779 if (!wxPyCheckForApp()) SWIG_fail;
32780 PyThreadState* __tstate = wxPyBeginAllowThreads();
32781 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32782
32783 wxPyEndAllowThreads(__tstate);
32784 if (PyErr_Occurred()) SWIG_fail;
32785 }
32786 {
32787 resultobj = wxPyMake_wxObject(result, 0);
32788 }
32789 return resultobj;
32790 fail:
32791 return NULL;
32792 }
32793
32794
32795 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32796 PyObject *resultobj;
32797 wxString *arg1 = 0 ;
32798 wxWindow *arg2 = (wxWindow *) NULL ;
32799 wxWindow *result;
32800 bool temp1 = false ;
32801 PyObject * obj0 = 0 ;
32802 PyObject * obj1 = 0 ;
32803 char *kwnames[] = {
32804 (char *) "name",(char *) "parent", NULL
32805 };
32806
32807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32808 {
32809 arg1 = wxString_in_helper(obj0);
32810 if (arg1 == NULL) SWIG_fail;
32811 temp1 = true;
32812 }
32813 if (obj1) {
32814 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32815 if (SWIG_arg_fail(2)) SWIG_fail;
32816 }
32817 {
32818 if (!wxPyCheckForApp()) SWIG_fail;
32819 PyThreadState* __tstate = wxPyBeginAllowThreads();
32820 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32821
32822 wxPyEndAllowThreads(__tstate);
32823 if (PyErr_Occurred()) SWIG_fail;
32824 }
32825 {
32826 resultobj = wxPyMake_wxObject(result, 0);
32827 }
32828 {
32829 if (temp1)
32830 delete arg1;
32831 }
32832 return resultobj;
32833 fail:
32834 {
32835 if (temp1)
32836 delete arg1;
32837 }
32838 return NULL;
32839 }
32840
32841
32842 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32843 PyObject *resultobj;
32844 wxString *arg1 = 0 ;
32845 wxWindow *arg2 = (wxWindow *) NULL ;
32846 wxWindow *result;
32847 bool temp1 = false ;
32848 PyObject * obj0 = 0 ;
32849 PyObject * obj1 = 0 ;
32850 char *kwnames[] = {
32851 (char *) "label",(char *) "parent", NULL
32852 };
32853
32854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32855 {
32856 arg1 = wxString_in_helper(obj0);
32857 if (arg1 == NULL) SWIG_fail;
32858 temp1 = true;
32859 }
32860 if (obj1) {
32861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32862 if (SWIG_arg_fail(2)) SWIG_fail;
32863 }
32864 {
32865 if (!wxPyCheckForApp()) SWIG_fail;
32866 PyThreadState* __tstate = wxPyBeginAllowThreads();
32867 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32868
32869 wxPyEndAllowThreads(__tstate);
32870 if (PyErr_Occurred()) SWIG_fail;
32871 }
32872 {
32873 resultobj = wxPyMake_wxObject(result, 0);
32874 }
32875 {
32876 if (temp1)
32877 delete arg1;
32878 }
32879 return resultobj;
32880 fail:
32881 {
32882 if (temp1)
32883 delete arg1;
32884 }
32885 return NULL;
32886 }
32887
32888
32889 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32890 PyObject *resultobj;
32891 wxWindow *arg1 = (wxWindow *) 0 ;
32892 unsigned long arg2 ;
32893 wxWindow *result;
32894 PyObject * obj0 = 0 ;
32895 PyObject * obj1 = 0 ;
32896 char *kwnames[] = {
32897 (char *) "parent",(char *) "_hWnd", NULL
32898 };
32899
32900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32902 if (SWIG_arg_fail(1)) SWIG_fail;
32903 {
32904 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32905 if (SWIG_arg_fail(2)) SWIG_fail;
32906 }
32907 {
32908 PyThreadState* __tstate = wxPyBeginAllowThreads();
32909 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32910
32911 wxPyEndAllowThreads(__tstate);
32912 if (PyErr_Occurred()) SWIG_fail;
32913 }
32914 {
32915 resultobj = wxPyMake_wxObject(result, 0);
32916 }
32917 return resultobj;
32918 fail:
32919 return NULL;
32920 }
32921
32922
32923 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32924 PyObject *resultobj;
32925 PyObject *result;
32926 char *kwnames[] = {
32927 NULL
32928 };
32929
32930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32931 {
32932 PyThreadState* __tstate = wxPyBeginAllowThreads();
32933 result = (PyObject *)GetTopLevelWindows();
32934
32935 wxPyEndAllowThreads(__tstate);
32936 if (PyErr_Occurred()) SWIG_fail;
32937 }
32938 resultobj = result;
32939 return resultobj;
32940 fail:
32941 return NULL;
32942 }
32943
32944
32945 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32946 PyObject *resultobj;
32947 wxValidator *result;
32948 char *kwnames[] = {
32949 NULL
32950 };
32951
32952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32953 {
32954 PyThreadState* __tstate = wxPyBeginAllowThreads();
32955 result = (wxValidator *)new wxValidator();
32956
32957 wxPyEndAllowThreads(__tstate);
32958 if (PyErr_Occurred()) SWIG_fail;
32959 }
32960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32961 return resultobj;
32962 fail:
32963 return NULL;
32964 }
32965
32966
32967 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32968 PyObject *resultobj;
32969 wxValidator *arg1 = (wxValidator *) 0 ;
32970 wxValidator *result;
32971 PyObject * obj0 = 0 ;
32972 char *kwnames[] = {
32973 (char *) "self", NULL
32974 };
32975
32976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32978 if (SWIG_arg_fail(1)) SWIG_fail;
32979 {
32980 PyThreadState* __tstate = wxPyBeginAllowThreads();
32981 result = (wxValidator *)(arg1)->Clone();
32982
32983 wxPyEndAllowThreads(__tstate);
32984 if (PyErr_Occurred()) SWIG_fail;
32985 }
32986 {
32987 resultobj = wxPyMake_wxObject(result, 0);
32988 }
32989 return resultobj;
32990 fail:
32991 return NULL;
32992 }
32993
32994
32995 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32996 PyObject *resultobj;
32997 wxValidator *arg1 = (wxValidator *) 0 ;
32998 wxWindow *arg2 = (wxWindow *) 0 ;
32999 bool result;
33000 PyObject * obj0 = 0 ;
33001 PyObject * obj1 = 0 ;
33002 char *kwnames[] = {
33003 (char *) "self",(char *) "parent", NULL
33004 };
33005
33006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
33007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33008 if (SWIG_arg_fail(1)) SWIG_fail;
33009 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33010 if (SWIG_arg_fail(2)) SWIG_fail;
33011 {
33012 PyThreadState* __tstate = wxPyBeginAllowThreads();
33013 result = (bool)(arg1)->Validate(arg2);
33014
33015 wxPyEndAllowThreads(__tstate);
33016 if (PyErr_Occurred()) SWIG_fail;
33017 }
33018 {
33019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33020 }
33021 return resultobj;
33022 fail:
33023 return NULL;
33024 }
33025
33026
33027 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33028 PyObject *resultobj;
33029 wxValidator *arg1 = (wxValidator *) 0 ;
33030 bool result;
33031 PyObject * obj0 = 0 ;
33032 char *kwnames[] = {
33033 (char *) "self", NULL
33034 };
33035
33036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
33037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33038 if (SWIG_arg_fail(1)) SWIG_fail;
33039 {
33040 PyThreadState* __tstate = wxPyBeginAllowThreads();
33041 result = (bool)(arg1)->TransferToWindow();
33042
33043 wxPyEndAllowThreads(__tstate);
33044 if (PyErr_Occurred()) SWIG_fail;
33045 }
33046 {
33047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33048 }
33049 return resultobj;
33050 fail:
33051 return NULL;
33052 }
33053
33054
33055 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33056 PyObject *resultobj;
33057 wxValidator *arg1 = (wxValidator *) 0 ;
33058 bool result;
33059 PyObject * obj0 = 0 ;
33060 char *kwnames[] = {
33061 (char *) "self", NULL
33062 };
33063
33064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
33065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33066 if (SWIG_arg_fail(1)) SWIG_fail;
33067 {
33068 PyThreadState* __tstate = wxPyBeginAllowThreads();
33069 result = (bool)(arg1)->TransferFromWindow();
33070
33071 wxPyEndAllowThreads(__tstate);
33072 if (PyErr_Occurred()) SWIG_fail;
33073 }
33074 {
33075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33076 }
33077 return resultobj;
33078 fail:
33079 return NULL;
33080 }
33081
33082
33083 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33084 PyObject *resultobj;
33085 wxValidator *arg1 = (wxValidator *) 0 ;
33086 wxWindow *result;
33087 PyObject * obj0 = 0 ;
33088 char *kwnames[] = {
33089 (char *) "self", NULL
33090 };
33091
33092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33094 if (SWIG_arg_fail(1)) SWIG_fail;
33095 {
33096 PyThreadState* __tstate = wxPyBeginAllowThreads();
33097 result = (wxWindow *)(arg1)->GetWindow();
33098
33099 wxPyEndAllowThreads(__tstate);
33100 if (PyErr_Occurred()) SWIG_fail;
33101 }
33102 {
33103 resultobj = wxPyMake_wxObject(result, 0);
33104 }
33105 return resultobj;
33106 fail:
33107 return NULL;
33108 }
33109
33110
33111 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33112 PyObject *resultobj;
33113 wxValidator *arg1 = (wxValidator *) 0 ;
33114 wxWindow *arg2 = (wxWindow *) 0 ;
33115 PyObject * obj0 = 0 ;
33116 PyObject * obj1 = 0 ;
33117 char *kwnames[] = {
33118 (char *) "self",(char *) "window", NULL
33119 };
33120
33121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33123 if (SWIG_arg_fail(1)) SWIG_fail;
33124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33125 if (SWIG_arg_fail(2)) SWIG_fail;
33126 {
33127 PyThreadState* __tstate = wxPyBeginAllowThreads();
33128 (arg1)->SetWindow(arg2);
33129
33130 wxPyEndAllowThreads(__tstate);
33131 if (PyErr_Occurred()) SWIG_fail;
33132 }
33133 Py_INCREF(Py_None); resultobj = Py_None;
33134 return resultobj;
33135 fail:
33136 return NULL;
33137 }
33138
33139
33140 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33141 PyObject *resultobj;
33142 bool result;
33143 char *kwnames[] = {
33144 NULL
33145 };
33146
33147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33148 {
33149 PyThreadState* __tstate = wxPyBeginAllowThreads();
33150 result = (bool)wxValidator::IsSilent();
33151
33152 wxPyEndAllowThreads(__tstate);
33153 if (PyErr_Occurred()) SWIG_fail;
33154 }
33155 {
33156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33157 }
33158 return resultobj;
33159 fail:
33160 return NULL;
33161 }
33162
33163
33164 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33165 PyObject *resultobj;
33166 int arg1 = (int) true ;
33167 PyObject * obj0 = 0 ;
33168 char *kwnames[] = {
33169 (char *) "doIt", NULL
33170 };
33171
33172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33173 if (obj0) {
33174 {
33175 arg1 = (int)(SWIG_As_int(obj0));
33176 if (SWIG_arg_fail(1)) SWIG_fail;
33177 }
33178 }
33179 {
33180 PyThreadState* __tstate = wxPyBeginAllowThreads();
33181 wxValidator::SetBellOnError(arg1);
33182
33183 wxPyEndAllowThreads(__tstate);
33184 if (PyErr_Occurred()) SWIG_fail;
33185 }
33186 Py_INCREF(Py_None); resultobj = Py_None;
33187 return resultobj;
33188 fail:
33189 return NULL;
33190 }
33191
33192
33193 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33194 PyObject *obj;
33195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33196 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33197 Py_INCREF(obj);
33198 return Py_BuildValue((char *)"");
33199 }
33200 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33201 PyObject *resultobj;
33202 wxPyValidator *result;
33203 char *kwnames[] = {
33204 NULL
33205 };
33206
33207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33208 {
33209 PyThreadState* __tstate = wxPyBeginAllowThreads();
33210 result = (wxPyValidator *)new wxPyValidator();
33211
33212 wxPyEndAllowThreads(__tstate);
33213 if (PyErr_Occurred()) SWIG_fail;
33214 }
33215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33216 return resultobj;
33217 fail:
33218 return NULL;
33219 }
33220
33221
33222 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33223 PyObject *resultobj;
33224 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33225 PyObject *arg2 = (PyObject *) 0 ;
33226 PyObject *arg3 = (PyObject *) 0 ;
33227 int arg4 = (int) true ;
33228 PyObject * obj0 = 0 ;
33229 PyObject * obj1 = 0 ;
33230 PyObject * obj2 = 0 ;
33231 PyObject * obj3 = 0 ;
33232 char *kwnames[] = {
33233 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33234 };
33235
33236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33238 if (SWIG_arg_fail(1)) SWIG_fail;
33239 arg2 = obj1;
33240 arg3 = obj2;
33241 if (obj3) {
33242 {
33243 arg4 = (int)(SWIG_As_int(obj3));
33244 if (SWIG_arg_fail(4)) SWIG_fail;
33245 }
33246 }
33247 {
33248 PyThreadState* __tstate = wxPyBeginAllowThreads();
33249 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33250
33251 wxPyEndAllowThreads(__tstate);
33252 if (PyErr_Occurred()) SWIG_fail;
33253 }
33254 Py_INCREF(Py_None); resultobj = Py_None;
33255 return resultobj;
33256 fail:
33257 return NULL;
33258 }
33259
33260
33261 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33262 PyObject *obj;
33263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33264 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33265 Py_INCREF(obj);
33266 return Py_BuildValue((char *)"");
33267 }
33268 static int _wrap_DefaultValidator_set(PyObject *) {
33269 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33270 return 1;
33271 }
33272
33273
33274 static PyObject *_wrap_DefaultValidator_get(void) {
33275 PyObject *pyobj;
33276
33277 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33278 return pyobj;
33279 }
33280
33281
33282 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33283 PyObject *resultobj;
33284 wxString const &arg1_defvalue = wxPyEmptyString ;
33285 wxString *arg1 = (wxString *) &arg1_defvalue ;
33286 long arg2 = (long) 0 ;
33287 wxMenu *result;
33288 bool temp1 = false ;
33289 PyObject * obj0 = 0 ;
33290 PyObject * obj1 = 0 ;
33291 char *kwnames[] = {
33292 (char *) "title",(char *) "style", NULL
33293 };
33294
33295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33296 if (obj0) {
33297 {
33298 arg1 = wxString_in_helper(obj0);
33299 if (arg1 == NULL) SWIG_fail;
33300 temp1 = true;
33301 }
33302 }
33303 if (obj1) {
33304 {
33305 arg2 = (long)(SWIG_As_long(obj1));
33306 if (SWIG_arg_fail(2)) SWIG_fail;
33307 }
33308 }
33309 {
33310 if (!wxPyCheckForApp()) SWIG_fail;
33311 PyThreadState* __tstate = wxPyBeginAllowThreads();
33312 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33313
33314 wxPyEndAllowThreads(__tstate);
33315 if (PyErr_Occurred()) SWIG_fail;
33316 }
33317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33318 {
33319 if (temp1)
33320 delete arg1;
33321 }
33322 return resultobj;
33323 fail:
33324 {
33325 if (temp1)
33326 delete arg1;
33327 }
33328 return NULL;
33329 }
33330
33331
33332 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33333 PyObject *resultobj;
33334 wxMenu *arg1 = (wxMenu *) 0 ;
33335 int arg2 ;
33336 wxString *arg3 = 0 ;
33337 wxString const &arg4_defvalue = wxPyEmptyString ;
33338 wxString *arg4 = (wxString *) &arg4_defvalue ;
33339 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33340 wxMenuItem *result;
33341 bool temp3 = false ;
33342 bool temp4 = false ;
33343 PyObject * obj0 = 0 ;
33344 PyObject * obj1 = 0 ;
33345 PyObject * obj2 = 0 ;
33346 PyObject * obj3 = 0 ;
33347 PyObject * obj4 = 0 ;
33348 char *kwnames[] = {
33349 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33350 };
33351
33352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33354 if (SWIG_arg_fail(1)) SWIG_fail;
33355 {
33356 arg2 = (int)(SWIG_As_int(obj1));
33357 if (SWIG_arg_fail(2)) SWIG_fail;
33358 }
33359 {
33360 arg3 = wxString_in_helper(obj2);
33361 if (arg3 == NULL) SWIG_fail;
33362 temp3 = true;
33363 }
33364 if (obj3) {
33365 {
33366 arg4 = wxString_in_helper(obj3);
33367 if (arg4 == NULL) SWIG_fail;
33368 temp4 = true;
33369 }
33370 }
33371 if (obj4) {
33372 {
33373 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33374 if (SWIG_arg_fail(5)) SWIG_fail;
33375 }
33376 }
33377 {
33378 PyThreadState* __tstate = wxPyBeginAllowThreads();
33379 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33380
33381 wxPyEndAllowThreads(__tstate);
33382 if (PyErr_Occurred()) SWIG_fail;
33383 }
33384 {
33385 resultobj = wxPyMake_wxObject(result, 0);
33386 }
33387 {
33388 if (temp3)
33389 delete arg3;
33390 }
33391 {
33392 if (temp4)
33393 delete arg4;
33394 }
33395 return resultobj;
33396 fail:
33397 {
33398 if (temp3)
33399 delete arg3;
33400 }
33401 {
33402 if (temp4)
33403 delete arg4;
33404 }
33405 return NULL;
33406 }
33407
33408
33409 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33410 PyObject *resultobj;
33411 wxMenu *arg1 = (wxMenu *) 0 ;
33412 wxMenuItem *result;
33413 PyObject * obj0 = 0 ;
33414 char *kwnames[] = {
33415 (char *) "self", NULL
33416 };
33417
33418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33420 if (SWIG_arg_fail(1)) SWIG_fail;
33421 {
33422 PyThreadState* __tstate = wxPyBeginAllowThreads();
33423 result = (wxMenuItem *)(arg1)->AppendSeparator();
33424
33425 wxPyEndAllowThreads(__tstate);
33426 if (PyErr_Occurred()) SWIG_fail;
33427 }
33428 {
33429 resultobj = wxPyMake_wxObject(result, 0);
33430 }
33431 return resultobj;
33432 fail:
33433 return NULL;
33434 }
33435
33436
33437 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33438 PyObject *resultobj;
33439 wxMenu *arg1 = (wxMenu *) 0 ;
33440 int arg2 ;
33441 wxString *arg3 = 0 ;
33442 wxString const &arg4_defvalue = wxPyEmptyString ;
33443 wxString *arg4 = (wxString *) &arg4_defvalue ;
33444 wxMenuItem *result;
33445 bool temp3 = false ;
33446 bool temp4 = false ;
33447 PyObject * obj0 = 0 ;
33448 PyObject * obj1 = 0 ;
33449 PyObject * obj2 = 0 ;
33450 PyObject * obj3 = 0 ;
33451 char *kwnames[] = {
33452 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33453 };
33454
33455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33457 if (SWIG_arg_fail(1)) SWIG_fail;
33458 {
33459 arg2 = (int)(SWIG_As_int(obj1));
33460 if (SWIG_arg_fail(2)) SWIG_fail;
33461 }
33462 {
33463 arg3 = wxString_in_helper(obj2);
33464 if (arg3 == NULL) SWIG_fail;
33465 temp3 = true;
33466 }
33467 if (obj3) {
33468 {
33469 arg4 = wxString_in_helper(obj3);
33470 if (arg4 == NULL) SWIG_fail;
33471 temp4 = true;
33472 }
33473 }
33474 {
33475 PyThreadState* __tstate = wxPyBeginAllowThreads();
33476 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33477
33478 wxPyEndAllowThreads(__tstate);
33479 if (PyErr_Occurred()) SWIG_fail;
33480 }
33481 {
33482 resultobj = wxPyMake_wxObject(result, 0);
33483 }
33484 {
33485 if (temp3)
33486 delete arg3;
33487 }
33488 {
33489 if (temp4)
33490 delete arg4;
33491 }
33492 return resultobj;
33493 fail:
33494 {
33495 if (temp3)
33496 delete arg3;
33497 }
33498 {
33499 if (temp4)
33500 delete arg4;
33501 }
33502 return NULL;
33503 }
33504
33505
33506 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33507 PyObject *resultobj;
33508 wxMenu *arg1 = (wxMenu *) 0 ;
33509 int arg2 ;
33510 wxString *arg3 = 0 ;
33511 wxString const &arg4_defvalue = wxPyEmptyString ;
33512 wxString *arg4 = (wxString *) &arg4_defvalue ;
33513 wxMenuItem *result;
33514 bool temp3 = false ;
33515 bool temp4 = false ;
33516 PyObject * obj0 = 0 ;
33517 PyObject * obj1 = 0 ;
33518 PyObject * obj2 = 0 ;
33519 PyObject * obj3 = 0 ;
33520 char *kwnames[] = {
33521 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33522 };
33523
33524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33526 if (SWIG_arg_fail(1)) SWIG_fail;
33527 {
33528 arg2 = (int)(SWIG_As_int(obj1));
33529 if (SWIG_arg_fail(2)) SWIG_fail;
33530 }
33531 {
33532 arg3 = wxString_in_helper(obj2);
33533 if (arg3 == NULL) SWIG_fail;
33534 temp3 = true;
33535 }
33536 if (obj3) {
33537 {
33538 arg4 = wxString_in_helper(obj3);
33539 if (arg4 == NULL) SWIG_fail;
33540 temp4 = true;
33541 }
33542 }
33543 {
33544 PyThreadState* __tstate = wxPyBeginAllowThreads();
33545 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33546
33547 wxPyEndAllowThreads(__tstate);
33548 if (PyErr_Occurred()) SWIG_fail;
33549 }
33550 {
33551 resultobj = wxPyMake_wxObject(result, 0);
33552 }
33553 {
33554 if (temp3)
33555 delete arg3;
33556 }
33557 {
33558 if (temp4)
33559 delete arg4;
33560 }
33561 return resultobj;
33562 fail:
33563 {
33564 if (temp3)
33565 delete arg3;
33566 }
33567 {
33568 if (temp4)
33569 delete arg4;
33570 }
33571 return NULL;
33572 }
33573
33574
33575 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33576 PyObject *resultobj;
33577 wxMenu *arg1 = (wxMenu *) 0 ;
33578 int arg2 ;
33579 wxString *arg3 = 0 ;
33580 wxMenu *arg4 = (wxMenu *) 0 ;
33581 wxString const &arg5_defvalue = wxPyEmptyString ;
33582 wxString *arg5 = (wxString *) &arg5_defvalue ;
33583 wxMenuItem *result;
33584 bool temp3 = false ;
33585 bool temp5 = false ;
33586 PyObject * obj0 = 0 ;
33587 PyObject * obj1 = 0 ;
33588 PyObject * obj2 = 0 ;
33589 PyObject * obj3 = 0 ;
33590 PyObject * obj4 = 0 ;
33591 char *kwnames[] = {
33592 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33593 };
33594
33595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33597 if (SWIG_arg_fail(1)) SWIG_fail;
33598 {
33599 arg2 = (int)(SWIG_As_int(obj1));
33600 if (SWIG_arg_fail(2)) SWIG_fail;
33601 }
33602 {
33603 arg3 = wxString_in_helper(obj2);
33604 if (arg3 == NULL) SWIG_fail;
33605 temp3 = true;
33606 }
33607 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33608 if (SWIG_arg_fail(4)) SWIG_fail;
33609 if (obj4) {
33610 {
33611 arg5 = wxString_in_helper(obj4);
33612 if (arg5 == NULL) SWIG_fail;
33613 temp5 = true;
33614 }
33615 }
33616 {
33617 PyThreadState* __tstate = wxPyBeginAllowThreads();
33618 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33619
33620 wxPyEndAllowThreads(__tstate);
33621 if (PyErr_Occurred()) SWIG_fail;
33622 }
33623 {
33624 resultobj = wxPyMake_wxObject(result, 0);
33625 }
33626 {
33627 if (temp3)
33628 delete arg3;
33629 }
33630 {
33631 if (temp5)
33632 delete arg5;
33633 }
33634 return resultobj;
33635 fail:
33636 {
33637 if (temp3)
33638 delete arg3;
33639 }
33640 {
33641 if (temp5)
33642 delete arg5;
33643 }
33644 return NULL;
33645 }
33646
33647
33648 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33649 PyObject *resultobj;
33650 wxMenu *arg1 = (wxMenu *) 0 ;
33651 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33652 wxMenuItem *result;
33653 PyObject * obj0 = 0 ;
33654 PyObject * obj1 = 0 ;
33655 char *kwnames[] = {
33656 (char *) "self",(char *) "item", NULL
33657 };
33658
33659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33661 if (SWIG_arg_fail(1)) SWIG_fail;
33662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33663 if (SWIG_arg_fail(2)) SWIG_fail;
33664 {
33665 PyThreadState* __tstate = wxPyBeginAllowThreads();
33666 result = (wxMenuItem *)(arg1)->Append(arg2);
33667
33668 wxPyEndAllowThreads(__tstate);
33669 if (PyErr_Occurred()) SWIG_fail;
33670 }
33671 {
33672 resultobj = wxPyMake_wxObject(result, 0);
33673 }
33674 return resultobj;
33675 fail:
33676 return NULL;
33677 }
33678
33679
33680 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33681 PyObject *resultobj;
33682 wxMenu *arg1 = (wxMenu *) 0 ;
33683 PyObject * obj0 = 0 ;
33684 char *kwnames[] = {
33685 (char *) "self", NULL
33686 };
33687
33688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33690 if (SWIG_arg_fail(1)) SWIG_fail;
33691 {
33692 PyThreadState* __tstate = wxPyBeginAllowThreads();
33693 (arg1)->Break();
33694
33695 wxPyEndAllowThreads(__tstate);
33696 if (PyErr_Occurred()) SWIG_fail;
33697 }
33698 Py_INCREF(Py_None); resultobj = Py_None;
33699 return resultobj;
33700 fail:
33701 return NULL;
33702 }
33703
33704
33705 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33706 PyObject *resultobj;
33707 wxMenu *arg1 = (wxMenu *) 0 ;
33708 size_t arg2 ;
33709 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33710 wxMenuItem *result;
33711 PyObject * obj0 = 0 ;
33712 PyObject * obj1 = 0 ;
33713 PyObject * obj2 = 0 ;
33714 char *kwnames[] = {
33715 (char *) "self",(char *) "pos",(char *) "item", NULL
33716 };
33717
33718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33720 if (SWIG_arg_fail(1)) SWIG_fail;
33721 {
33722 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33723 if (SWIG_arg_fail(2)) SWIG_fail;
33724 }
33725 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33726 if (SWIG_arg_fail(3)) SWIG_fail;
33727 {
33728 PyThreadState* __tstate = wxPyBeginAllowThreads();
33729 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33730
33731 wxPyEndAllowThreads(__tstate);
33732 if (PyErr_Occurred()) SWIG_fail;
33733 }
33734 {
33735 resultobj = wxPyMake_wxObject(result, 0);
33736 }
33737 return resultobj;
33738 fail:
33739 return NULL;
33740 }
33741
33742
33743 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33744 PyObject *resultobj;
33745 wxMenu *arg1 = (wxMenu *) 0 ;
33746 size_t arg2 ;
33747 int arg3 ;
33748 wxString *arg4 = 0 ;
33749 wxString const &arg5_defvalue = wxPyEmptyString ;
33750 wxString *arg5 = (wxString *) &arg5_defvalue ;
33751 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33752 wxMenuItem *result;
33753 bool temp4 = false ;
33754 bool temp5 = false ;
33755 PyObject * obj0 = 0 ;
33756 PyObject * obj1 = 0 ;
33757 PyObject * obj2 = 0 ;
33758 PyObject * obj3 = 0 ;
33759 PyObject * obj4 = 0 ;
33760 PyObject * obj5 = 0 ;
33761 char *kwnames[] = {
33762 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33763 };
33764
33765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33767 if (SWIG_arg_fail(1)) SWIG_fail;
33768 {
33769 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33770 if (SWIG_arg_fail(2)) SWIG_fail;
33771 }
33772 {
33773 arg3 = (int)(SWIG_As_int(obj2));
33774 if (SWIG_arg_fail(3)) SWIG_fail;
33775 }
33776 {
33777 arg4 = wxString_in_helper(obj3);
33778 if (arg4 == NULL) SWIG_fail;
33779 temp4 = true;
33780 }
33781 if (obj4) {
33782 {
33783 arg5 = wxString_in_helper(obj4);
33784 if (arg5 == NULL) SWIG_fail;
33785 temp5 = true;
33786 }
33787 }
33788 if (obj5) {
33789 {
33790 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33791 if (SWIG_arg_fail(6)) SWIG_fail;
33792 }
33793 }
33794 {
33795 PyThreadState* __tstate = wxPyBeginAllowThreads();
33796 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33797
33798 wxPyEndAllowThreads(__tstate);
33799 if (PyErr_Occurred()) SWIG_fail;
33800 }
33801 {
33802 resultobj = wxPyMake_wxObject(result, 0);
33803 }
33804 {
33805 if (temp4)
33806 delete arg4;
33807 }
33808 {
33809 if (temp5)
33810 delete arg5;
33811 }
33812 return resultobj;
33813 fail:
33814 {
33815 if (temp4)
33816 delete arg4;
33817 }
33818 {
33819 if (temp5)
33820 delete arg5;
33821 }
33822 return NULL;
33823 }
33824
33825
33826 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33827 PyObject *resultobj;
33828 wxMenu *arg1 = (wxMenu *) 0 ;
33829 size_t arg2 ;
33830 wxMenuItem *result;
33831 PyObject * obj0 = 0 ;
33832 PyObject * obj1 = 0 ;
33833 char *kwnames[] = {
33834 (char *) "self",(char *) "pos", NULL
33835 };
33836
33837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33839 if (SWIG_arg_fail(1)) SWIG_fail;
33840 {
33841 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33842 if (SWIG_arg_fail(2)) SWIG_fail;
33843 }
33844 {
33845 PyThreadState* __tstate = wxPyBeginAllowThreads();
33846 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33847
33848 wxPyEndAllowThreads(__tstate);
33849 if (PyErr_Occurred()) SWIG_fail;
33850 }
33851 {
33852 resultobj = wxPyMake_wxObject(result, 0);
33853 }
33854 return resultobj;
33855 fail:
33856 return NULL;
33857 }
33858
33859
33860 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33861 PyObject *resultobj;
33862 wxMenu *arg1 = (wxMenu *) 0 ;
33863 size_t arg2 ;
33864 int arg3 ;
33865 wxString *arg4 = 0 ;
33866 wxString const &arg5_defvalue = wxPyEmptyString ;
33867 wxString *arg5 = (wxString *) &arg5_defvalue ;
33868 wxMenuItem *result;
33869 bool temp4 = false ;
33870 bool temp5 = false ;
33871 PyObject * obj0 = 0 ;
33872 PyObject * obj1 = 0 ;
33873 PyObject * obj2 = 0 ;
33874 PyObject * obj3 = 0 ;
33875 PyObject * obj4 = 0 ;
33876 char *kwnames[] = {
33877 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33878 };
33879
33880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33882 if (SWIG_arg_fail(1)) SWIG_fail;
33883 {
33884 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33885 if (SWIG_arg_fail(2)) SWIG_fail;
33886 }
33887 {
33888 arg3 = (int)(SWIG_As_int(obj2));
33889 if (SWIG_arg_fail(3)) SWIG_fail;
33890 }
33891 {
33892 arg4 = wxString_in_helper(obj3);
33893 if (arg4 == NULL) SWIG_fail;
33894 temp4 = true;
33895 }
33896 if (obj4) {
33897 {
33898 arg5 = wxString_in_helper(obj4);
33899 if (arg5 == NULL) SWIG_fail;
33900 temp5 = true;
33901 }
33902 }
33903 {
33904 PyThreadState* __tstate = wxPyBeginAllowThreads();
33905 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33906
33907 wxPyEndAllowThreads(__tstate);
33908 if (PyErr_Occurred()) SWIG_fail;
33909 }
33910 {
33911 resultobj = wxPyMake_wxObject(result, 0);
33912 }
33913 {
33914 if (temp4)
33915 delete arg4;
33916 }
33917 {
33918 if (temp5)
33919 delete arg5;
33920 }
33921 return resultobj;
33922 fail:
33923 {
33924 if (temp4)
33925 delete arg4;
33926 }
33927 {
33928 if (temp5)
33929 delete arg5;
33930 }
33931 return NULL;
33932 }
33933
33934
33935 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33936 PyObject *resultobj;
33937 wxMenu *arg1 = (wxMenu *) 0 ;
33938 size_t arg2 ;
33939 int arg3 ;
33940 wxString *arg4 = 0 ;
33941 wxString const &arg5_defvalue = wxPyEmptyString ;
33942 wxString *arg5 = (wxString *) &arg5_defvalue ;
33943 wxMenuItem *result;
33944 bool temp4 = false ;
33945 bool temp5 = false ;
33946 PyObject * obj0 = 0 ;
33947 PyObject * obj1 = 0 ;
33948 PyObject * obj2 = 0 ;
33949 PyObject * obj3 = 0 ;
33950 PyObject * obj4 = 0 ;
33951 char *kwnames[] = {
33952 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33953 };
33954
33955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33957 if (SWIG_arg_fail(1)) SWIG_fail;
33958 {
33959 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33960 if (SWIG_arg_fail(2)) SWIG_fail;
33961 }
33962 {
33963 arg3 = (int)(SWIG_As_int(obj2));
33964 if (SWIG_arg_fail(3)) SWIG_fail;
33965 }
33966 {
33967 arg4 = wxString_in_helper(obj3);
33968 if (arg4 == NULL) SWIG_fail;
33969 temp4 = true;
33970 }
33971 if (obj4) {
33972 {
33973 arg5 = wxString_in_helper(obj4);
33974 if (arg5 == NULL) SWIG_fail;
33975 temp5 = true;
33976 }
33977 }
33978 {
33979 PyThreadState* __tstate = wxPyBeginAllowThreads();
33980 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33981
33982 wxPyEndAllowThreads(__tstate);
33983 if (PyErr_Occurred()) SWIG_fail;
33984 }
33985 {
33986 resultobj = wxPyMake_wxObject(result, 0);
33987 }
33988 {
33989 if (temp4)
33990 delete arg4;
33991 }
33992 {
33993 if (temp5)
33994 delete arg5;
33995 }
33996 return resultobj;
33997 fail:
33998 {
33999 if (temp4)
34000 delete arg4;
34001 }
34002 {
34003 if (temp5)
34004 delete arg5;
34005 }
34006 return NULL;
34007 }
34008
34009
34010 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34011 PyObject *resultobj;
34012 wxMenu *arg1 = (wxMenu *) 0 ;
34013 size_t arg2 ;
34014 int arg3 ;
34015 wxString *arg4 = 0 ;
34016 wxMenu *arg5 = (wxMenu *) 0 ;
34017 wxString const &arg6_defvalue = wxPyEmptyString ;
34018 wxString *arg6 = (wxString *) &arg6_defvalue ;
34019 wxMenuItem *result;
34020 bool temp4 = false ;
34021 bool temp6 = false ;
34022 PyObject * obj0 = 0 ;
34023 PyObject * obj1 = 0 ;
34024 PyObject * obj2 = 0 ;
34025 PyObject * obj3 = 0 ;
34026 PyObject * obj4 = 0 ;
34027 PyObject * obj5 = 0 ;
34028 char *kwnames[] = {
34029 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34030 };
34031
34032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34037 if (SWIG_arg_fail(2)) SWIG_fail;
34038 }
34039 {
34040 arg3 = (int)(SWIG_As_int(obj2));
34041 if (SWIG_arg_fail(3)) SWIG_fail;
34042 }
34043 {
34044 arg4 = wxString_in_helper(obj3);
34045 if (arg4 == NULL) SWIG_fail;
34046 temp4 = true;
34047 }
34048 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34049 if (SWIG_arg_fail(5)) SWIG_fail;
34050 if (obj5) {
34051 {
34052 arg6 = wxString_in_helper(obj5);
34053 if (arg6 == NULL) SWIG_fail;
34054 temp6 = true;
34055 }
34056 }
34057 {
34058 PyThreadState* __tstate = wxPyBeginAllowThreads();
34059 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
34060
34061 wxPyEndAllowThreads(__tstate);
34062 if (PyErr_Occurred()) SWIG_fail;
34063 }
34064 {
34065 resultobj = wxPyMake_wxObject(result, 0);
34066 }
34067 {
34068 if (temp4)
34069 delete arg4;
34070 }
34071 {
34072 if (temp6)
34073 delete arg6;
34074 }
34075 return resultobj;
34076 fail:
34077 {
34078 if (temp4)
34079 delete arg4;
34080 }
34081 {
34082 if (temp6)
34083 delete arg6;
34084 }
34085 return NULL;
34086 }
34087
34088
34089 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34090 PyObject *resultobj;
34091 wxMenu *arg1 = (wxMenu *) 0 ;
34092 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34093 wxMenuItem *result;
34094 PyObject * obj0 = 0 ;
34095 PyObject * obj1 = 0 ;
34096 char *kwnames[] = {
34097 (char *) "self",(char *) "item", NULL
34098 };
34099
34100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34102 if (SWIG_arg_fail(1)) SWIG_fail;
34103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34104 if (SWIG_arg_fail(2)) SWIG_fail;
34105 {
34106 PyThreadState* __tstate = wxPyBeginAllowThreads();
34107 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34108
34109 wxPyEndAllowThreads(__tstate);
34110 if (PyErr_Occurred()) SWIG_fail;
34111 }
34112 {
34113 resultobj = wxPyMake_wxObject(result, 0);
34114 }
34115 return resultobj;
34116 fail:
34117 return NULL;
34118 }
34119
34120
34121 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34122 PyObject *resultobj;
34123 wxMenu *arg1 = (wxMenu *) 0 ;
34124 int arg2 ;
34125 wxString *arg3 = 0 ;
34126 wxString const &arg4_defvalue = wxPyEmptyString ;
34127 wxString *arg4 = (wxString *) &arg4_defvalue ;
34128 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34129 wxMenuItem *result;
34130 bool temp3 = false ;
34131 bool temp4 = false ;
34132 PyObject * obj0 = 0 ;
34133 PyObject * obj1 = 0 ;
34134 PyObject * obj2 = 0 ;
34135 PyObject * obj3 = 0 ;
34136 PyObject * obj4 = 0 ;
34137 char *kwnames[] = {
34138 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34139 };
34140
34141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34143 if (SWIG_arg_fail(1)) SWIG_fail;
34144 {
34145 arg2 = (int)(SWIG_As_int(obj1));
34146 if (SWIG_arg_fail(2)) SWIG_fail;
34147 }
34148 {
34149 arg3 = wxString_in_helper(obj2);
34150 if (arg3 == NULL) SWIG_fail;
34151 temp3 = true;
34152 }
34153 if (obj3) {
34154 {
34155 arg4 = wxString_in_helper(obj3);
34156 if (arg4 == NULL) SWIG_fail;
34157 temp4 = true;
34158 }
34159 }
34160 if (obj4) {
34161 {
34162 arg5 = (wxItemKind)(SWIG_As_int(obj4));
34163 if (SWIG_arg_fail(5)) SWIG_fail;
34164 }
34165 }
34166 {
34167 PyThreadState* __tstate = wxPyBeginAllowThreads();
34168 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
34169
34170 wxPyEndAllowThreads(__tstate);
34171 if (PyErr_Occurred()) SWIG_fail;
34172 }
34173 {
34174 resultobj = wxPyMake_wxObject(result, 0);
34175 }
34176 {
34177 if (temp3)
34178 delete arg3;
34179 }
34180 {
34181 if (temp4)
34182 delete arg4;
34183 }
34184 return resultobj;
34185 fail:
34186 {
34187 if (temp3)
34188 delete arg3;
34189 }
34190 {
34191 if (temp4)
34192 delete arg4;
34193 }
34194 return NULL;
34195 }
34196
34197
34198 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34199 PyObject *resultobj;
34200 wxMenu *arg1 = (wxMenu *) 0 ;
34201 wxMenuItem *result;
34202 PyObject * obj0 = 0 ;
34203 char *kwnames[] = {
34204 (char *) "self", NULL
34205 };
34206
34207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34209 if (SWIG_arg_fail(1)) SWIG_fail;
34210 {
34211 PyThreadState* __tstate = wxPyBeginAllowThreads();
34212 result = (wxMenuItem *)(arg1)->PrependSeparator();
34213
34214 wxPyEndAllowThreads(__tstate);
34215 if (PyErr_Occurred()) SWIG_fail;
34216 }
34217 {
34218 resultobj = wxPyMake_wxObject(result, 0);
34219 }
34220 return resultobj;
34221 fail:
34222 return NULL;
34223 }
34224
34225
34226 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34227 PyObject *resultobj;
34228 wxMenu *arg1 = (wxMenu *) 0 ;
34229 int arg2 ;
34230 wxString *arg3 = 0 ;
34231 wxString const &arg4_defvalue = wxPyEmptyString ;
34232 wxString *arg4 = (wxString *) &arg4_defvalue ;
34233 wxMenuItem *result;
34234 bool temp3 = false ;
34235 bool temp4 = false ;
34236 PyObject * obj0 = 0 ;
34237 PyObject * obj1 = 0 ;
34238 PyObject * obj2 = 0 ;
34239 PyObject * obj3 = 0 ;
34240 char *kwnames[] = {
34241 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34242 };
34243
34244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 = wxString_in_helper(obj2);
34253 if (arg3 == NULL) SWIG_fail;
34254 temp3 = true;
34255 }
34256 if (obj3) {
34257 {
34258 arg4 = wxString_in_helper(obj3);
34259 if (arg4 == NULL) SWIG_fail;
34260 temp4 = true;
34261 }
34262 }
34263 {
34264 PyThreadState* __tstate = wxPyBeginAllowThreads();
34265 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34266
34267 wxPyEndAllowThreads(__tstate);
34268 if (PyErr_Occurred()) SWIG_fail;
34269 }
34270 {
34271 resultobj = wxPyMake_wxObject(result, 0);
34272 }
34273 {
34274 if (temp3)
34275 delete arg3;
34276 }
34277 {
34278 if (temp4)
34279 delete arg4;
34280 }
34281 return resultobj;
34282 fail:
34283 {
34284 if (temp3)
34285 delete arg3;
34286 }
34287 {
34288 if (temp4)
34289 delete arg4;
34290 }
34291 return NULL;
34292 }
34293
34294
34295 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34296 PyObject *resultobj;
34297 wxMenu *arg1 = (wxMenu *) 0 ;
34298 int arg2 ;
34299 wxString *arg3 = 0 ;
34300 wxString const &arg4_defvalue = wxPyEmptyString ;
34301 wxString *arg4 = (wxString *) &arg4_defvalue ;
34302 wxMenuItem *result;
34303 bool temp3 = false ;
34304 bool temp4 = false ;
34305 PyObject * obj0 = 0 ;
34306 PyObject * obj1 = 0 ;
34307 PyObject * obj2 = 0 ;
34308 PyObject * obj3 = 0 ;
34309 char *kwnames[] = {
34310 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34311 };
34312
34313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34315 if (SWIG_arg_fail(1)) SWIG_fail;
34316 {
34317 arg2 = (int)(SWIG_As_int(obj1));
34318 if (SWIG_arg_fail(2)) SWIG_fail;
34319 }
34320 {
34321 arg3 = wxString_in_helper(obj2);
34322 if (arg3 == NULL) SWIG_fail;
34323 temp3 = true;
34324 }
34325 if (obj3) {
34326 {
34327 arg4 = wxString_in_helper(obj3);
34328 if (arg4 == NULL) SWIG_fail;
34329 temp4 = true;
34330 }
34331 }
34332 {
34333 PyThreadState* __tstate = wxPyBeginAllowThreads();
34334 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34335
34336 wxPyEndAllowThreads(__tstate);
34337 if (PyErr_Occurred()) SWIG_fail;
34338 }
34339 {
34340 resultobj = wxPyMake_wxObject(result, 0);
34341 }
34342 {
34343 if (temp3)
34344 delete arg3;
34345 }
34346 {
34347 if (temp4)
34348 delete arg4;
34349 }
34350 return resultobj;
34351 fail:
34352 {
34353 if (temp3)
34354 delete arg3;
34355 }
34356 {
34357 if (temp4)
34358 delete arg4;
34359 }
34360 return NULL;
34361 }
34362
34363
34364 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34365 PyObject *resultobj;
34366 wxMenu *arg1 = (wxMenu *) 0 ;
34367 int arg2 ;
34368 wxString *arg3 = 0 ;
34369 wxMenu *arg4 = (wxMenu *) 0 ;
34370 wxString const &arg5_defvalue = wxPyEmptyString ;
34371 wxString *arg5 = (wxString *) &arg5_defvalue ;
34372 wxMenuItem *result;
34373 bool temp3 = false ;
34374 bool temp5 = false ;
34375 PyObject * obj0 = 0 ;
34376 PyObject * obj1 = 0 ;
34377 PyObject * obj2 = 0 ;
34378 PyObject * obj3 = 0 ;
34379 PyObject * obj4 = 0 ;
34380 char *kwnames[] = {
34381 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34382 };
34383
34384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34386 if (SWIG_arg_fail(1)) SWIG_fail;
34387 {
34388 arg2 = (int)(SWIG_As_int(obj1));
34389 if (SWIG_arg_fail(2)) SWIG_fail;
34390 }
34391 {
34392 arg3 = wxString_in_helper(obj2);
34393 if (arg3 == NULL) SWIG_fail;
34394 temp3 = true;
34395 }
34396 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34397 if (SWIG_arg_fail(4)) SWIG_fail;
34398 if (obj4) {
34399 {
34400 arg5 = wxString_in_helper(obj4);
34401 if (arg5 == NULL) SWIG_fail;
34402 temp5 = true;
34403 }
34404 }
34405 {
34406 PyThreadState* __tstate = wxPyBeginAllowThreads();
34407 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34408
34409 wxPyEndAllowThreads(__tstate);
34410 if (PyErr_Occurred()) SWIG_fail;
34411 }
34412 {
34413 resultobj = wxPyMake_wxObject(result, 0);
34414 }
34415 {
34416 if (temp3)
34417 delete arg3;
34418 }
34419 {
34420 if (temp5)
34421 delete arg5;
34422 }
34423 return resultobj;
34424 fail:
34425 {
34426 if (temp3)
34427 delete arg3;
34428 }
34429 {
34430 if (temp5)
34431 delete arg5;
34432 }
34433 return NULL;
34434 }
34435
34436
34437 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34438 PyObject *resultobj;
34439 wxMenu *arg1 = (wxMenu *) 0 ;
34440 int arg2 ;
34441 wxMenuItem *result;
34442 PyObject * obj0 = 0 ;
34443 PyObject * obj1 = 0 ;
34444 char *kwnames[] = {
34445 (char *) "self",(char *) "id", NULL
34446 };
34447
34448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34450 if (SWIG_arg_fail(1)) SWIG_fail;
34451 {
34452 arg2 = (int)(SWIG_As_int(obj1));
34453 if (SWIG_arg_fail(2)) SWIG_fail;
34454 }
34455 {
34456 PyThreadState* __tstate = wxPyBeginAllowThreads();
34457 result = (wxMenuItem *)(arg1)->Remove(arg2);
34458
34459 wxPyEndAllowThreads(__tstate);
34460 if (PyErr_Occurred()) SWIG_fail;
34461 }
34462 {
34463 resultobj = wxPyMake_wxObject(result, 0);
34464 }
34465 return resultobj;
34466 fail:
34467 return NULL;
34468 }
34469
34470
34471 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34472 PyObject *resultobj;
34473 wxMenu *arg1 = (wxMenu *) 0 ;
34474 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34475 wxMenuItem *result;
34476 PyObject * obj0 = 0 ;
34477 PyObject * obj1 = 0 ;
34478 char *kwnames[] = {
34479 (char *) "self",(char *) "item", NULL
34480 };
34481
34482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34484 if (SWIG_arg_fail(1)) SWIG_fail;
34485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34486 if (SWIG_arg_fail(2)) SWIG_fail;
34487 {
34488 PyThreadState* __tstate = wxPyBeginAllowThreads();
34489 result = (wxMenuItem *)(arg1)->Remove(arg2);
34490
34491 wxPyEndAllowThreads(__tstate);
34492 if (PyErr_Occurred()) SWIG_fail;
34493 }
34494 {
34495 resultobj = wxPyMake_wxObject(result, 0);
34496 }
34497 return resultobj;
34498 fail:
34499 return NULL;
34500 }
34501
34502
34503 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34504 PyObject *resultobj;
34505 wxMenu *arg1 = (wxMenu *) 0 ;
34506 int arg2 ;
34507 bool result;
34508 PyObject * obj0 = 0 ;
34509 PyObject * obj1 = 0 ;
34510 char *kwnames[] = {
34511 (char *) "self",(char *) "id", NULL
34512 };
34513
34514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34516 if (SWIG_arg_fail(1)) SWIG_fail;
34517 {
34518 arg2 = (int)(SWIG_As_int(obj1));
34519 if (SWIG_arg_fail(2)) SWIG_fail;
34520 }
34521 {
34522 PyThreadState* __tstate = wxPyBeginAllowThreads();
34523 result = (bool)(arg1)->Delete(arg2);
34524
34525 wxPyEndAllowThreads(__tstate);
34526 if (PyErr_Occurred()) SWIG_fail;
34527 }
34528 {
34529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34530 }
34531 return resultobj;
34532 fail:
34533 return NULL;
34534 }
34535
34536
34537 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34538 PyObject *resultobj;
34539 wxMenu *arg1 = (wxMenu *) 0 ;
34540 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34541 bool result;
34542 PyObject * obj0 = 0 ;
34543 PyObject * obj1 = 0 ;
34544 char *kwnames[] = {
34545 (char *) "self",(char *) "item", NULL
34546 };
34547
34548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34550 if (SWIG_arg_fail(1)) SWIG_fail;
34551 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34552 if (SWIG_arg_fail(2)) SWIG_fail;
34553 {
34554 PyThreadState* __tstate = wxPyBeginAllowThreads();
34555 result = (bool)(arg1)->Delete(arg2);
34556
34557 wxPyEndAllowThreads(__tstate);
34558 if (PyErr_Occurred()) SWIG_fail;
34559 }
34560 {
34561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34562 }
34563 return resultobj;
34564 fail:
34565 return NULL;
34566 }
34567
34568
34569 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34570 PyObject *resultobj;
34571 wxMenu *arg1 = (wxMenu *) 0 ;
34572 PyObject * obj0 = 0 ;
34573 char *kwnames[] = {
34574 (char *) "self", NULL
34575 };
34576
34577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34579 if (SWIG_arg_fail(1)) SWIG_fail;
34580 {
34581 PyThreadState* __tstate = wxPyBeginAllowThreads();
34582 wxMenu_Destroy(arg1);
34583
34584 wxPyEndAllowThreads(__tstate);
34585 if (PyErr_Occurred()) SWIG_fail;
34586 }
34587 Py_INCREF(Py_None); resultobj = Py_None;
34588 return resultobj;
34589 fail:
34590 return NULL;
34591 }
34592
34593
34594 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34595 PyObject *resultobj;
34596 wxMenu *arg1 = (wxMenu *) 0 ;
34597 int arg2 ;
34598 bool result;
34599 PyObject * obj0 = 0 ;
34600 PyObject * obj1 = 0 ;
34601 char *kwnames[] = {
34602 (char *) "self",(char *) "id", NULL
34603 };
34604
34605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34607 if (SWIG_arg_fail(1)) SWIG_fail;
34608 {
34609 arg2 = (int)(SWIG_As_int(obj1));
34610 if (SWIG_arg_fail(2)) SWIG_fail;
34611 }
34612 {
34613 PyThreadState* __tstate = wxPyBeginAllowThreads();
34614 result = (bool)(arg1)->Destroy(arg2);
34615
34616 wxPyEndAllowThreads(__tstate);
34617 if (PyErr_Occurred()) SWIG_fail;
34618 }
34619 {
34620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34621 }
34622 return resultobj;
34623 fail:
34624 return NULL;
34625 }
34626
34627
34628 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34629 PyObject *resultobj;
34630 wxMenu *arg1 = (wxMenu *) 0 ;
34631 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34632 bool result;
34633 PyObject * obj0 = 0 ;
34634 PyObject * obj1 = 0 ;
34635 char *kwnames[] = {
34636 (char *) "self",(char *) "item", NULL
34637 };
34638
34639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34641 if (SWIG_arg_fail(1)) SWIG_fail;
34642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34643 if (SWIG_arg_fail(2)) SWIG_fail;
34644 {
34645 PyThreadState* __tstate = wxPyBeginAllowThreads();
34646 result = (bool)(arg1)->Destroy(arg2);
34647
34648 wxPyEndAllowThreads(__tstate);
34649 if (PyErr_Occurred()) SWIG_fail;
34650 }
34651 {
34652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34653 }
34654 return resultobj;
34655 fail:
34656 return NULL;
34657 }
34658
34659
34660 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34661 PyObject *resultobj;
34662 wxMenu *arg1 = (wxMenu *) 0 ;
34663 size_t result;
34664 PyObject * obj0 = 0 ;
34665 char *kwnames[] = {
34666 (char *) "self", NULL
34667 };
34668
34669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",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 = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34675
34676 wxPyEndAllowThreads(__tstate);
34677 if (PyErr_Occurred()) SWIG_fail;
34678 }
34679 {
34680 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34681 }
34682 return resultobj;
34683 fail:
34684 return NULL;
34685 }
34686
34687
34688 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34689 PyObject *resultobj;
34690 wxMenu *arg1 = (wxMenu *) 0 ;
34691 PyObject *result;
34692 PyObject * obj0 = 0 ;
34693 char *kwnames[] = {
34694 (char *) "self", NULL
34695 };
34696
34697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34699 if (SWIG_arg_fail(1)) SWIG_fail;
34700 {
34701 PyThreadState* __tstate = wxPyBeginAllowThreads();
34702 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34703
34704 wxPyEndAllowThreads(__tstate);
34705 if (PyErr_Occurred()) SWIG_fail;
34706 }
34707 resultobj = result;
34708 return resultobj;
34709 fail:
34710 return NULL;
34711 }
34712
34713
34714 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34715 PyObject *resultobj;
34716 wxMenu *arg1 = (wxMenu *) 0 ;
34717 wxString *arg2 = 0 ;
34718 int result;
34719 bool temp2 = false ;
34720 PyObject * obj0 = 0 ;
34721 PyObject * obj1 = 0 ;
34722 char *kwnames[] = {
34723 (char *) "self",(char *) "item", NULL
34724 };
34725
34726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34728 if (SWIG_arg_fail(1)) SWIG_fail;
34729 {
34730 arg2 = wxString_in_helper(obj1);
34731 if (arg2 == NULL) SWIG_fail;
34732 temp2 = true;
34733 }
34734 {
34735 PyThreadState* __tstate = wxPyBeginAllowThreads();
34736 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34737
34738 wxPyEndAllowThreads(__tstate);
34739 if (PyErr_Occurred()) SWIG_fail;
34740 }
34741 {
34742 resultobj = SWIG_From_int((int)(result));
34743 }
34744 {
34745 if (temp2)
34746 delete arg2;
34747 }
34748 return resultobj;
34749 fail:
34750 {
34751 if (temp2)
34752 delete arg2;
34753 }
34754 return NULL;
34755 }
34756
34757
34758 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34759 PyObject *resultobj;
34760 wxMenu *arg1 = (wxMenu *) 0 ;
34761 int arg2 ;
34762 wxMenuItem *result;
34763 PyObject * obj0 = 0 ;
34764 PyObject * obj1 = 0 ;
34765 char *kwnames[] = {
34766 (char *) "self",(char *) "id", NULL
34767 };
34768
34769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34771 if (SWIG_arg_fail(1)) SWIG_fail;
34772 {
34773 arg2 = (int)(SWIG_As_int(obj1));
34774 if (SWIG_arg_fail(2)) SWIG_fail;
34775 }
34776 {
34777 PyThreadState* __tstate = wxPyBeginAllowThreads();
34778 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34779
34780 wxPyEndAllowThreads(__tstate);
34781 if (PyErr_Occurred()) SWIG_fail;
34782 }
34783 {
34784 resultobj = wxPyMake_wxObject(result, 0);
34785 }
34786 return resultobj;
34787 fail:
34788 return NULL;
34789 }
34790
34791
34792 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34793 PyObject *resultobj;
34794 wxMenu *arg1 = (wxMenu *) 0 ;
34795 size_t arg2 ;
34796 wxMenuItem *result;
34797 PyObject * obj0 = 0 ;
34798 PyObject * obj1 = 0 ;
34799 char *kwnames[] = {
34800 (char *) "self",(char *) "position", NULL
34801 };
34802
34803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34805 if (SWIG_arg_fail(1)) SWIG_fail;
34806 {
34807 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34808 if (SWIG_arg_fail(2)) SWIG_fail;
34809 }
34810 {
34811 PyThreadState* __tstate = wxPyBeginAllowThreads();
34812 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34813
34814 wxPyEndAllowThreads(__tstate);
34815 if (PyErr_Occurred()) SWIG_fail;
34816 }
34817 {
34818 resultobj = wxPyMake_wxObject(result, 0);
34819 }
34820 return resultobj;
34821 fail:
34822 return NULL;
34823 }
34824
34825
34826 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34827 PyObject *resultobj;
34828 wxMenu *arg1 = (wxMenu *) 0 ;
34829 int arg2 ;
34830 bool arg3 ;
34831 PyObject * obj0 = 0 ;
34832 PyObject * obj1 = 0 ;
34833 PyObject * obj2 = 0 ;
34834 char *kwnames[] = {
34835 (char *) "self",(char *) "id",(char *) "enable", NULL
34836 };
34837
34838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34840 if (SWIG_arg_fail(1)) SWIG_fail;
34841 {
34842 arg2 = (int)(SWIG_As_int(obj1));
34843 if (SWIG_arg_fail(2)) SWIG_fail;
34844 }
34845 {
34846 arg3 = (bool)(SWIG_As_bool(obj2));
34847 if (SWIG_arg_fail(3)) SWIG_fail;
34848 }
34849 {
34850 PyThreadState* __tstate = wxPyBeginAllowThreads();
34851 (arg1)->Enable(arg2,arg3);
34852
34853 wxPyEndAllowThreads(__tstate);
34854 if (PyErr_Occurred()) SWIG_fail;
34855 }
34856 Py_INCREF(Py_None); resultobj = Py_None;
34857 return resultobj;
34858 fail:
34859 return NULL;
34860 }
34861
34862
34863 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34864 PyObject *resultobj;
34865 wxMenu *arg1 = (wxMenu *) 0 ;
34866 int arg2 ;
34867 bool result;
34868 PyObject * obj0 = 0 ;
34869 PyObject * obj1 = 0 ;
34870 char *kwnames[] = {
34871 (char *) "self",(char *) "id", NULL
34872 };
34873
34874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34876 if (SWIG_arg_fail(1)) SWIG_fail;
34877 {
34878 arg2 = (int)(SWIG_As_int(obj1));
34879 if (SWIG_arg_fail(2)) SWIG_fail;
34880 }
34881 {
34882 PyThreadState* __tstate = wxPyBeginAllowThreads();
34883 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34884
34885 wxPyEndAllowThreads(__tstate);
34886 if (PyErr_Occurred()) SWIG_fail;
34887 }
34888 {
34889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34890 }
34891 return resultobj;
34892 fail:
34893 return NULL;
34894 }
34895
34896
34897 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34898 PyObject *resultobj;
34899 wxMenu *arg1 = (wxMenu *) 0 ;
34900 int arg2 ;
34901 bool arg3 ;
34902 PyObject * obj0 = 0 ;
34903 PyObject * obj1 = 0 ;
34904 PyObject * obj2 = 0 ;
34905 char *kwnames[] = {
34906 (char *) "self",(char *) "id",(char *) "check", NULL
34907 };
34908
34909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34911 if (SWIG_arg_fail(1)) SWIG_fail;
34912 {
34913 arg2 = (int)(SWIG_As_int(obj1));
34914 if (SWIG_arg_fail(2)) SWIG_fail;
34915 }
34916 {
34917 arg3 = (bool)(SWIG_As_bool(obj2));
34918 if (SWIG_arg_fail(3)) SWIG_fail;
34919 }
34920 {
34921 PyThreadState* __tstate = wxPyBeginAllowThreads();
34922 (arg1)->Check(arg2,arg3);
34923
34924 wxPyEndAllowThreads(__tstate);
34925 if (PyErr_Occurred()) SWIG_fail;
34926 }
34927 Py_INCREF(Py_None); resultobj = Py_None;
34928 return resultobj;
34929 fail:
34930 return NULL;
34931 }
34932
34933
34934 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34935 PyObject *resultobj;
34936 wxMenu *arg1 = (wxMenu *) 0 ;
34937 int arg2 ;
34938 bool result;
34939 PyObject * obj0 = 0 ;
34940 PyObject * obj1 = 0 ;
34941 char *kwnames[] = {
34942 (char *) "self",(char *) "id", NULL
34943 };
34944
34945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34947 if (SWIG_arg_fail(1)) SWIG_fail;
34948 {
34949 arg2 = (int)(SWIG_As_int(obj1));
34950 if (SWIG_arg_fail(2)) SWIG_fail;
34951 }
34952 {
34953 PyThreadState* __tstate = wxPyBeginAllowThreads();
34954 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34955
34956 wxPyEndAllowThreads(__tstate);
34957 if (PyErr_Occurred()) SWIG_fail;
34958 }
34959 {
34960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34961 }
34962 return resultobj;
34963 fail:
34964 return NULL;
34965 }
34966
34967
34968 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34969 PyObject *resultobj;
34970 wxMenu *arg1 = (wxMenu *) 0 ;
34971 int arg2 ;
34972 wxString *arg3 = 0 ;
34973 bool temp3 = false ;
34974 PyObject * obj0 = 0 ;
34975 PyObject * obj1 = 0 ;
34976 PyObject * obj2 = 0 ;
34977 char *kwnames[] = {
34978 (char *) "self",(char *) "id",(char *) "label", NULL
34979 };
34980
34981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34983 if (SWIG_arg_fail(1)) SWIG_fail;
34984 {
34985 arg2 = (int)(SWIG_As_int(obj1));
34986 if (SWIG_arg_fail(2)) SWIG_fail;
34987 }
34988 {
34989 arg3 = wxString_in_helper(obj2);
34990 if (arg3 == NULL) SWIG_fail;
34991 temp3 = true;
34992 }
34993 {
34994 PyThreadState* __tstate = wxPyBeginAllowThreads();
34995 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34996
34997 wxPyEndAllowThreads(__tstate);
34998 if (PyErr_Occurred()) SWIG_fail;
34999 }
35000 Py_INCREF(Py_None); resultobj = Py_None;
35001 {
35002 if (temp3)
35003 delete arg3;
35004 }
35005 return resultobj;
35006 fail:
35007 {
35008 if (temp3)
35009 delete arg3;
35010 }
35011 return NULL;
35012 }
35013
35014
35015 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35016 PyObject *resultobj;
35017 wxMenu *arg1 = (wxMenu *) 0 ;
35018 int arg2 ;
35019 wxString result;
35020 PyObject * obj0 = 0 ;
35021 PyObject * obj1 = 0 ;
35022 char *kwnames[] = {
35023 (char *) "self",(char *) "id", NULL
35024 };
35025
35026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35028 if (SWIG_arg_fail(1)) SWIG_fail;
35029 {
35030 arg2 = (int)(SWIG_As_int(obj1));
35031 if (SWIG_arg_fail(2)) SWIG_fail;
35032 }
35033 {
35034 PyThreadState* __tstate = wxPyBeginAllowThreads();
35035 result = ((wxMenu const *)arg1)->GetLabel(arg2);
35036
35037 wxPyEndAllowThreads(__tstate);
35038 if (PyErr_Occurred()) SWIG_fail;
35039 }
35040 {
35041 #if wxUSE_UNICODE
35042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35043 #else
35044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35045 #endif
35046 }
35047 return resultobj;
35048 fail:
35049 return NULL;
35050 }
35051
35052
35053 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35054 PyObject *resultobj;
35055 wxMenu *arg1 = (wxMenu *) 0 ;
35056 int arg2 ;
35057 wxString *arg3 = 0 ;
35058 bool temp3 = false ;
35059 PyObject * obj0 = 0 ;
35060 PyObject * obj1 = 0 ;
35061 PyObject * obj2 = 0 ;
35062 char *kwnames[] = {
35063 (char *) "self",(char *) "id",(char *) "helpString", NULL
35064 };
35065
35066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35068 if (SWIG_arg_fail(1)) SWIG_fail;
35069 {
35070 arg2 = (int)(SWIG_As_int(obj1));
35071 if (SWIG_arg_fail(2)) SWIG_fail;
35072 }
35073 {
35074 arg3 = wxString_in_helper(obj2);
35075 if (arg3 == NULL) SWIG_fail;
35076 temp3 = true;
35077 }
35078 {
35079 PyThreadState* __tstate = wxPyBeginAllowThreads();
35080 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35081
35082 wxPyEndAllowThreads(__tstate);
35083 if (PyErr_Occurred()) SWIG_fail;
35084 }
35085 Py_INCREF(Py_None); resultobj = Py_None;
35086 {
35087 if (temp3)
35088 delete arg3;
35089 }
35090 return resultobj;
35091 fail:
35092 {
35093 if (temp3)
35094 delete arg3;
35095 }
35096 return NULL;
35097 }
35098
35099
35100 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35101 PyObject *resultobj;
35102 wxMenu *arg1 = (wxMenu *) 0 ;
35103 int arg2 ;
35104 wxString result;
35105 PyObject * obj0 = 0 ;
35106 PyObject * obj1 = 0 ;
35107 char *kwnames[] = {
35108 (char *) "self",(char *) "id", NULL
35109 };
35110
35111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35113 if (SWIG_arg_fail(1)) SWIG_fail;
35114 {
35115 arg2 = (int)(SWIG_As_int(obj1));
35116 if (SWIG_arg_fail(2)) SWIG_fail;
35117 }
35118 {
35119 PyThreadState* __tstate = wxPyBeginAllowThreads();
35120 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35121
35122 wxPyEndAllowThreads(__tstate);
35123 if (PyErr_Occurred()) SWIG_fail;
35124 }
35125 {
35126 #if wxUSE_UNICODE
35127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35128 #else
35129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35130 #endif
35131 }
35132 return resultobj;
35133 fail:
35134 return NULL;
35135 }
35136
35137
35138 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35139 PyObject *resultobj;
35140 wxMenu *arg1 = (wxMenu *) 0 ;
35141 wxString *arg2 = 0 ;
35142 bool temp2 = false ;
35143 PyObject * obj0 = 0 ;
35144 PyObject * obj1 = 0 ;
35145 char *kwnames[] = {
35146 (char *) "self",(char *) "title", NULL
35147 };
35148
35149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35151 if (SWIG_arg_fail(1)) SWIG_fail;
35152 {
35153 arg2 = wxString_in_helper(obj1);
35154 if (arg2 == NULL) SWIG_fail;
35155 temp2 = true;
35156 }
35157 {
35158 PyThreadState* __tstate = wxPyBeginAllowThreads();
35159 (arg1)->SetTitle((wxString const &)*arg2);
35160
35161 wxPyEndAllowThreads(__tstate);
35162 if (PyErr_Occurred()) SWIG_fail;
35163 }
35164 Py_INCREF(Py_None); resultobj = Py_None;
35165 {
35166 if (temp2)
35167 delete arg2;
35168 }
35169 return resultobj;
35170 fail:
35171 {
35172 if (temp2)
35173 delete arg2;
35174 }
35175 return NULL;
35176 }
35177
35178
35179 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35180 PyObject *resultobj;
35181 wxMenu *arg1 = (wxMenu *) 0 ;
35182 wxString result;
35183 PyObject * obj0 = 0 ;
35184 char *kwnames[] = {
35185 (char *) "self", NULL
35186 };
35187
35188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35190 if (SWIG_arg_fail(1)) SWIG_fail;
35191 {
35192 PyThreadState* __tstate = wxPyBeginAllowThreads();
35193 result = ((wxMenu const *)arg1)->GetTitle();
35194
35195 wxPyEndAllowThreads(__tstate);
35196 if (PyErr_Occurred()) SWIG_fail;
35197 }
35198 {
35199 #if wxUSE_UNICODE
35200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35201 #else
35202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35203 #endif
35204 }
35205 return resultobj;
35206 fail:
35207 return NULL;
35208 }
35209
35210
35211 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35212 PyObject *resultobj;
35213 wxMenu *arg1 = (wxMenu *) 0 ;
35214 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35215 PyObject * obj0 = 0 ;
35216 PyObject * obj1 = 0 ;
35217 char *kwnames[] = {
35218 (char *) "self",(char *) "handler", NULL
35219 };
35220
35221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35223 if (SWIG_arg_fail(1)) SWIG_fail;
35224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35225 if (SWIG_arg_fail(2)) SWIG_fail;
35226 {
35227 PyThreadState* __tstate = wxPyBeginAllowThreads();
35228 (arg1)->SetEventHandler(arg2);
35229
35230 wxPyEndAllowThreads(__tstate);
35231 if (PyErr_Occurred()) SWIG_fail;
35232 }
35233 Py_INCREF(Py_None); resultobj = Py_None;
35234 return resultobj;
35235 fail:
35236 return NULL;
35237 }
35238
35239
35240 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35241 PyObject *resultobj;
35242 wxMenu *arg1 = (wxMenu *) 0 ;
35243 wxEvtHandler *result;
35244 PyObject * obj0 = 0 ;
35245 char *kwnames[] = {
35246 (char *) "self", NULL
35247 };
35248
35249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35251 if (SWIG_arg_fail(1)) SWIG_fail;
35252 {
35253 PyThreadState* __tstate = wxPyBeginAllowThreads();
35254 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35255
35256 wxPyEndAllowThreads(__tstate);
35257 if (PyErr_Occurred()) SWIG_fail;
35258 }
35259 {
35260 resultobj = wxPyMake_wxObject(result, 0);
35261 }
35262 return resultobj;
35263 fail:
35264 return NULL;
35265 }
35266
35267
35268 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35269 PyObject *resultobj;
35270 wxMenu *arg1 = (wxMenu *) 0 ;
35271 wxWindow *arg2 = (wxWindow *) 0 ;
35272 PyObject * obj0 = 0 ;
35273 PyObject * obj1 = 0 ;
35274 char *kwnames[] = {
35275 (char *) "self",(char *) "win", NULL
35276 };
35277
35278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35280 if (SWIG_arg_fail(1)) SWIG_fail;
35281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35282 if (SWIG_arg_fail(2)) SWIG_fail;
35283 {
35284 PyThreadState* __tstate = wxPyBeginAllowThreads();
35285 (arg1)->SetInvokingWindow(arg2);
35286
35287 wxPyEndAllowThreads(__tstate);
35288 if (PyErr_Occurred()) SWIG_fail;
35289 }
35290 Py_INCREF(Py_None); resultobj = Py_None;
35291 return resultobj;
35292 fail:
35293 return NULL;
35294 }
35295
35296
35297 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35298 PyObject *resultobj;
35299 wxMenu *arg1 = (wxMenu *) 0 ;
35300 wxWindow *result;
35301 PyObject * obj0 = 0 ;
35302 char *kwnames[] = {
35303 (char *) "self", NULL
35304 };
35305
35306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35308 if (SWIG_arg_fail(1)) SWIG_fail;
35309 {
35310 PyThreadState* __tstate = wxPyBeginAllowThreads();
35311 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35312
35313 wxPyEndAllowThreads(__tstate);
35314 if (PyErr_Occurred()) SWIG_fail;
35315 }
35316 {
35317 resultobj = wxPyMake_wxObject(result, 0);
35318 }
35319 return resultobj;
35320 fail:
35321 return NULL;
35322 }
35323
35324
35325 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35326 PyObject *resultobj;
35327 wxMenu *arg1 = (wxMenu *) 0 ;
35328 long result;
35329 PyObject * obj0 = 0 ;
35330 char *kwnames[] = {
35331 (char *) "self", NULL
35332 };
35333
35334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35336 if (SWIG_arg_fail(1)) SWIG_fail;
35337 {
35338 PyThreadState* __tstate = wxPyBeginAllowThreads();
35339 result = (long)((wxMenu const *)arg1)->GetStyle();
35340
35341 wxPyEndAllowThreads(__tstate);
35342 if (PyErr_Occurred()) SWIG_fail;
35343 }
35344 {
35345 resultobj = SWIG_From_long((long)(result));
35346 }
35347 return resultobj;
35348 fail:
35349 return NULL;
35350 }
35351
35352
35353 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35354 PyObject *resultobj;
35355 wxMenu *arg1 = (wxMenu *) 0 ;
35356 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35357 PyObject * obj0 = 0 ;
35358 PyObject * obj1 = 0 ;
35359 char *kwnames[] = {
35360 (char *) "self",(char *) "source", NULL
35361 };
35362
35363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35365 if (SWIG_arg_fail(1)) SWIG_fail;
35366 if (obj1) {
35367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35368 if (SWIG_arg_fail(2)) SWIG_fail;
35369 }
35370 {
35371 PyThreadState* __tstate = wxPyBeginAllowThreads();
35372 (arg1)->UpdateUI(arg2);
35373
35374 wxPyEndAllowThreads(__tstate);
35375 if (PyErr_Occurred()) SWIG_fail;
35376 }
35377 Py_INCREF(Py_None); resultobj = Py_None;
35378 return resultobj;
35379 fail:
35380 return NULL;
35381 }
35382
35383
35384 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35385 PyObject *resultobj;
35386 wxMenu *arg1 = (wxMenu *) 0 ;
35387 wxMenuBar *result;
35388 PyObject * obj0 = 0 ;
35389 char *kwnames[] = {
35390 (char *) "self", NULL
35391 };
35392
35393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35395 if (SWIG_arg_fail(1)) SWIG_fail;
35396 {
35397 PyThreadState* __tstate = wxPyBeginAllowThreads();
35398 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35399
35400 wxPyEndAllowThreads(__tstate);
35401 if (PyErr_Occurred()) SWIG_fail;
35402 }
35403 {
35404 resultobj = wxPyMake_wxObject(result, 0);
35405 }
35406 return resultobj;
35407 fail:
35408 return NULL;
35409 }
35410
35411
35412 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35413 PyObject *resultobj;
35414 wxMenu *arg1 = (wxMenu *) 0 ;
35415 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35416 PyObject * obj0 = 0 ;
35417 PyObject * obj1 = 0 ;
35418 char *kwnames[] = {
35419 (char *) "self",(char *) "menubar", NULL
35420 };
35421
35422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35424 if (SWIG_arg_fail(1)) SWIG_fail;
35425 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35426 if (SWIG_arg_fail(2)) SWIG_fail;
35427 {
35428 PyThreadState* __tstate = wxPyBeginAllowThreads();
35429 (arg1)->Attach(arg2);
35430
35431 wxPyEndAllowThreads(__tstate);
35432 if (PyErr_Occurred()) SWIG_fail;
35433 }
35434 Py_INCREF(Py_None); resultobj = Py_None;
35435 return resultobj;
35436 fail:
35437 return NULL;
35438 }
35439
35440
35441 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35442 PyObject *resultobj;
35443 wxMenu *arg1 = (wxMenu *) 0 ;
35444 PyObject * obj0 = 0 ;
35445 char *kwnames[] = {
35446 (char *) "self", NULL
35447 };
35448
35449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35451 if (SWIG_arg_fail(1)) SWIG_fail;
35452 {
35453 PyThreadState* __tstate = wxPyBeginAllowThreads();
35454 (arg1)->Detach();
35455
35456 wxPyEndAllowThreads(__tstate);
35457 if (PyErr_Occurred()) SWIG_fail;
35458 }
35459 Py_INCREF(Py_None); resultobj = Py_None;
35460 return resultobj;
35461 fail:
35462 return NULL;
35463 }
35464
35465
35466 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35467 PyObject *resultobj;
35468 wxMenu *arg1 = (wxMenu *) 0 ;
35469 bool result;
35470 PyObject * obj0 = 0 ;
35471 char *kwnames[] = {
35472 (char *) "self", NULL
35473 };
35474
35475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35477 if (SWIG_arg_fail(1)) SWIG_fail;
35478 {
35479 PyThreadState* __tstate = wxPyBeginAllowThreads();
35480 result = (bool)((wxMenu const *)arg1)->IsAttached();
35481
35482 wxPyEndAllowThreads(__tstate);
35483 if (PyErr_Occurred()) SWIG_fail;
35484 }
35485 {
35486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35487 }
35488 return resultobj;
35489 fail:
35490 return NULL;
35491 }
35492
35493
35494 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35495 PyObject *resultobj;
35496 wxMenu *arg1 = (wxMenu *) 0 ;
35497 wxMenu *arg2 = (wxMenu *) 0 ;
35498 PyObject * obj0 = 0 ;
35499 PyObject * obj1 = 0 ;
35500 char *kwnames[] = {
35501 (char *) "self",(char *) "parent", NULL
35502 };
35503
35504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35506 if (SWIG_arg_fail(1)) SWIG_fail;
35507 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35508 if (SWIG_arg_fail(2)) SWIG_fail;
35509 {
35510 PyThreadState* __tstate = wxPyBeginAllowThreads();
35511 (arg1)->SetParent(arg2);
35512
35513 wxPyEndAllowThreads(__tstate);
35514 if (PyErr_Occurred()) SWIG_fail;
35515 }
35516 Py_INCREF(Py_None); resultobj = Py_None;
35517 return resultobj;
35518 fail:
35519 return NULL;
35520 }
35521
35522
35523 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35524 PyObject *resultobj;
35525 wxMenu *arg1 = (wxMenu *) 0 ;
35526 wxMenu *result;
35527 PyObject * obj0 = 0 ;
35528 char *kwnames[] = {
35529 (char *) "self", NULL
35530 };
35531
35532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35534 if (SWIG_arg_fail(1)) SWIG_fail;
35535 {
35536 PyThreadState* __tstate = wxPyBeginAllowThreads();
35537 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35538
35539 wxPyEndAllowThreads(__tstate);
35540 if (PyErr_Occurred()) SWIG_fail;
35541 }
35542 {
35543 resultobj = wxPyMake_wxObject(result, 0);
35544 }
35545 return resultobj;
35546 fail:
35547 return NULL;
35548 }
35549
35550
35551 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35552 PyObject *obj;
35553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35554 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35555 Py_INCREF(obj);
35556 return Py_BuildValue((char *)"");
35557 }
35558 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35559 PyObject *resultobj;
35560 long arg1 = (long) 0 ;
35561 wxMenuBar *result;
35562 PyObject * obj0 = 0 ;
35563 char *kwnames[] = {
35564 (char *) "style", NULL
35565 };
35566
35567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35568 if (obj0) {
35569 {
35570 arg1 = (long)(SWIG_As_long(obj0));
35571 if (SWIG_arg_fail(1)) SWIG_fail;
35572 }
35573 }
35574 {
35575 if (!wxPyCheckForApp()) SWIG_fail;
35576 PyThreadState* __tstate = wxPyBeginAllowThreads();
35577 result = (wxMenuBar *)new wxMenuBar(arg1);
35578
35579 wxPyEndAllowThreads(__tstate);
35580 if (PyErr_Occurred()) SWIG_fail;
35581 }
35582 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35583 return resultobj;
35584 fail:
35585 return NULL;
35586 }
35587
35588
35589 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35590 PyObject *resultobj;
35591 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35592 wxMenu *arg2 = (wxMenu *) 0 ;
35593 wxString *arg3 = 0 ;
35594 bool result;
35595 bool temp3 = false ;
35596 PyObject * obj0 = 0 ;
35597 PyObject * obj1 = 0 ;
35598 PyObject * obj2 = 0 ;
35599 char *kwnames[] = {
35600 (char *) "self",(char *) "menu",(char *) "title", NULL
35601 };
35602
35603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35605 if (SWIG_arg_fail(1)) SWIG_fail;
35606 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35607 if (SWIG_arg_fail(2)) SWIG_fail;
35608 {
35609 arg3 = wxString_in_helper(obj2);
35610 if (arg3 == NULL) SWIG_fail;
35611 temp3 = true;
35612 }
35613 {
35614 PyThreadState* __tstate = wxPyBeginAllowThreads();
35615 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35616
35617 wxPyEndAllowThreads(__tstate);
35618 if (PyErr_Occurred()) SWIG_fail;
35619 }
35620 {
35621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35622 }
35623 {
35624 if (temp3)
35625 delete arg3;
35626 }
35627 return resultobj;
35628 fail:
35629 {
35630 if (temp3)
35631 delete arg3;
35632 }
35633 return NULL;
35634 }
35635
35636
35637 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35638 PyObject *resultobj;
35639 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35640 size_t arg2 ;
35641 wxMenu *arg3 = (wxMenu *) 0 ;
35642 wxString *arg4 = 0 ;
35643 bool result;
35644 bool temp4 = false ;
35645 PyObject * obj0 = 0 ;
35646 PyObject * obj1 = 0 ;
35647 PyObject * obj2 = 0 ;
35648 PyObject * obj3 = 0 ;
35649 char *kwnames[] = {
35650 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35651 };
35652
35653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35655 if (SWIG_arg_fail(1)) SWIG_fail;
35656 {
35657 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35658 if (SWIG_arg_fail(2)) SWIG_fail;
35659 }
35660 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35661 if (SWIG_arg_fail(3)) SWIG_fail;
35662 {
35663 arg4 = wxString_in_helper(obj3);
35664 if (arg4 == NULL) SWIG_fail;
35665 temp4 = true;
35666 }
35667 {
35668 PyThreadState* __tstate = wxPyBeginAllowThreads();
35669 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35670
35671 wxPyEndAllowThreads(__tstate);
35672 if (PyErr_Occurred()) SWIG_fail;
35673 }
35674 {
35675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35676 }
35677 {
35678 if (temp4)
35679 delete arg4;
35680 }
35681 return resultobj;
35682 fail:
35683 {
35684 if (temp4)
35685 delete arg4;
35686 }
35687 return NULL;
35688 }
35689
35690
35691 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35692 PyObject *resultobj;
35693 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35694 size_t result;
35695 PyObject * obj0 = 0 ;
35696 char *kwnames[] = {
35697 (char *) "self", NULL
35698 };
35699
35700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35702 if (SWIG_arg_fail(1)) SWIG_fail;
35703 {
35704 PyThreadState* __tstate = wxPyBeginAllowThreads();
35705 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35706
35707 wxPyEndAllowThreads(__tstate);
35708 if (PyErr_Occurred()) SWIG_fail;
35709 }
35710 {
35711 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35712 }
35713 return resultobj;
35714 fail:
35715 return NULL;
35716 }
35717
35718
35719 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35720 PyObject *resultobj;
35721 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35722 size_t arg2 ;
35723 wxMenu *result;
35724 PyObject * obj0 = 0 ;
35725 PyObject * obj1 = 0 ;
35726 char *kwnames[] = {
35727 (char *) "self",(char *) "pos", NULL
35728 };
35729
35730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35732 if (SWIG_arg_fail(1)) SWIG_fail;
35733 {
35734 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35735 if (SWIG_arg_fail(2)) SWIG_fail;
35736 }
35737 {
35738 PyThreadState* __tstate = wxPyBeginAllowThreads();
35739 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35740
35741 wxPyEndAllowThreads(__tstate);
35742 if (PyErr_Occurred()) SWIG_fail;
35743 }
35744 {
35745 resultobj = wxPyMake_wxObject(result, 0);
35746 }
35747 return resultobj;
35748 fail:
35749 return NULL;
35750 }
35751
35752
35753 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35754 PyObject *resultobj;
35755 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35756 size_t arg2 ;
35757 wxMenu *arg3 = (wxMenu *) 0 ;
35758 wxString *arg4 = 0 ;
35759 wxMenu *result;
35760 bool temp4 = false ;
35761 PyObject * obj0 = 0 ;
35762 PyObject * obj1 = 0 ;
35763 PyObject * obj2 = 0 ;
35764 PyObject * obj3 = 0 ;
35765 char *kwnames[] = {
35766 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35767 };
35768
35769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35771 if (SWIG_arg_fail(1)) SWIG_fail;
35772 {
35773 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35774 if (SWIG_arg_fail(2)) SWIG_fail;
35775 }
35776 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35777 if (SWIG_arg_fail(3)) SWIG_fail;
35778 {
35779 arg4 = wxString_in_helper(obj3);
35780 if (arg4 == NULL) SWIG_fail;
35781 temp4 = true;
35782 }
35783 {
35784 PyThreadState* __tstate = wxPyBeginAllowThreads();
35785 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35786
35787 wxPyEndAllowThreads(__tstate);
35788 if (PyErr_Occurred()) SWIG_fail;
35789 }
35790 {
35791 resultobj = wxPyMake_wxObject(result, 0);
35792 }
35793 {
35794 if (temp4)
35795 delete arg4;
35796 }
35797 return resultobj;
35798 fail:
35799 {
35800 if (temp4)
35801 delete arg4;
35802 }
35803 return NULL;
35804 }
35805
35806
35807 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35808 PyObject *resultobj;
35809 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35810 size_t arg2 ;
35811 wxMenu *result;
35812 PyObject * obj0 = 0 ;
35813 PyObject * obj1 = 0 ;
35814 char *kwnames[] = {
35815 (char *) "self",(char *) "pos", NULL
35816 };
35817
35818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35820 if (SWIG_arg_fail(1)) SWIG_fail;
35821 {
35822 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35823 if (SWIG_arg_fail(2)) SWIG_fail;
35824 }
35825 {
35826 PyThreadState* __tstate = wxPyBeginAllowThreads();
35827 result = (wxMenu *)(arg1)->Remove(arg2);
35828
35829 wxPyEndAllowThreads(__tstate);
35830 if (PyErr_Occurred()) SWIG_fail;
35831 }
35832 {
35833 resultobj = wxPyMake_wxObject(result, 0);
35834 }
35835 return resultobj;
35836 fail:
35837 return NULL;
35838 }
35839
35840
35841 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35842 PyObject *resultobj;
35843 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35844 size_t arg2 ;
35845 bool arg3 ;
35846 PyObject * obj0 = 0 ;
35847 PyObject * obj1 = 0 ;
35848 PyObject * obj2 = 0 ;
35849 char *kwnames[] = {
35850 (char *) "self",(char *) "pos",(char *) "enable", NULL
35851 };
35852
35853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35855 if (SWIG_arg_fail(1)) SWIG_fail;
35856 {
35857 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35858 if (SWIG_arg_fail(2)) SWIG_fail;
35859 }
35860 {
35861 arg3 = (bool)(SWIG_As_bool(obj2));
35862 if (SWIG_arg_fail(3)) SWIG_fail;
35863 }
35864 {
35865 PyThreadState* __tstate = wxPyBeginAllowThreads();
35866 (arg1)->EnableTop(arg2,arg3);
35867
35868 wxPyEndAllowThreads(__tstate);
35869 if (PyErr_Occurred()) SWIG_fail;
35870 }
35871 Py_INCREF(Py_None); resultobj = Py_None;
35872 return resultobj;
35873 fail:
35874 return NULL;
35875 }
35876
35877
35878 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35879 PyObject *resultobj;
35880 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35881 size_t arg2 ;
35882 bool result;
35883 PyObject * obj0 = 0 ;
35884 PyObject * obj1 = 0 ;
35885 char *kwnames[] = {
35886 (char *) "self",(char *) "pos", NULL
35887 };
35888
35889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35891 if (SWIG_arg_fail(1)) SWIG_fail;
35892 {
35893 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35894 if (SWIG_arg_fail(2)) SWIG_fail;
35895 }
35896 {
35897 PyThreadState* __tstate = wxPyBeginAllowThreads();
35898 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35899
35900 wxPyEndAllowThreads(__tstate);
35901 if (PyErr_Occurred()) SWIG_fail;
35902 }
35903 {
35904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35905 }
35906 return resultobj;
35907 fail:
35908 return NULL;
35909 }
35910
35911
35912 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35913 PyObject *resultobj;
35914 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35915 size_t arg2 ;
35916 wxString *arg3 = 0 ;
35917 bool temp3 = false ;
35918 PyObject * obj0 = 0 ;
35919 PyObject * obj1 = 0 ;
35920 PyObject * obj2 = 0 ;
35921 char *kwnames[] = {
35922 (char *) "self",(char *) "pos",(char *) "label", NULL
35923 };
35924
35925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35927 if (SWIG_arg_fail(1)) SWIG_fail;
35928 {
35929 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35930 if (SWIG_arg_fail(2)) SWIG_fail;
35931 }
35932 {
35933 arg3 = wxString_in_helper(obj2);
35934 if (arg3 == NULL) SWIG_fail;
35935 temp3 = true;
35936 }
35937 {
35938 PyThreadState* __tstate = wxPyBeginAllowThreads();
35939 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35940
35941 wxPyEndAllowThreads(__tstate);
35942 if (PyErr_Occurred()) SWIG_fail;
35943 }
35944 Py_INCREF(Py_None); resultobj = Py_None;
35945 {
35946 if (temp3)
35947 delete arg3;
35948 }
35949 return resultobj;
35950 fail:
35951 {
35952 if (temp3)
35953 delete arg3;
35954 }
35955 return NULL;
35956 }
35957
35958
35959 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35960 PyObject *resultobj;
35961 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35962 size_t arg2 ;
35963 wxString result;
35964 PyObject * obj0 = 0 ;
35965 PyObject * obj1 = 0 ;
35966 char *kwnames[] = {
35967 (char *) "self",(char *) "pos", NULL
35968 };
35969
35970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35972 if (SWIG_arg_fail(1)) SWIG_fail;
35973 {
35974 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35975 if (SWIG_arg_fail(2)) SWIG_fail;
35976 }
35977 {
35978 PyThreadState* __tstate = wxPyBeginAllowThreads();
35979 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35980
35981 wxPyEndAllowThreads(__tstate);
35982 if (PyErr_Occurred()) SWIG_fail;
35983 }
35984 {
35985 #if wxUSE_UNICODE
35986 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35987 #else
35988 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35989 #endif
35990 }
35991 return resultobj;
35992 fail:
35993 return NULL;
35994 }
35995
35996
35997 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35998 PyObject *resultobj;
35999 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36000 wxString *arg2 = 0 ;
36001 wxString *arg3 = 0 ;
36002 int result;
36003 bool temp2 = false ;
36004 bool temp3 = false ;
36005 PyObject * obj0 = 0 ;
36006 PyObject * obj1 = 0 ;
36007 PyObject * obj2 = 0 ;
36008 char *kwnames[] = {
36009 (char *) "self",(char *) "menu",(char *) "item", NULL
36010 };
36011
36012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
36013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36014 if (SWIG_arg_fail(1)) SWIG_fail;
36015 {
36016 arg2 = wxString_in_helper(obj1);
36017 if (arg2 == NULL) SWIG_fail;
36018 temp2 = true;
36019 }
36020 {
36021 arg3 = wxString_in_helper(obj2);
36022 if (arg3 == NULL) SWIG_fail;
36023 temp3 = true;
36024 }
36025 {
36026 PyThreadState* __tstate = wxPyBeginAllowThreads();
36027 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
36028
36029 wxPyEndAllowThreads(__tstate);
36030 if (PyErr_Occurred()) SWIG_fail;
36031 }
36032 {
36033 resultobj = SWIG_From_int((int)(result));
36034 }
36035 {
36036 if (temp2)
36037 delete arg2;
36038 }
36039 {
36040 if (temp3)
36041 delete arg3;
36042 }
36043 return resultobj;
36044 fail:
36045 {
36046 if (temp2)
36047 delete arg2;
36048 }
36049 {
36050 if (temp3)
36051 delete arg3;
36052 }
36053 return NULL;
36054 }
36055
36056
36057 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
36058 PyObject *resultobj;
36059 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36060 int arg2 ;
36061 wxMenuItem *result;
36062 PyObject * obj0 = 0 ;
36063 PyObject * obj1 = 0 ;
36064 char *kwnames[] = {
36065 (char *) "self",(char *) "id", NULL
36066 };
36067
36068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
36069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36070 if (SWIG_arg_fail(1)) SWIG_fail;
36071 {
36072 arg2 = (int)(SWIG_As_int(obj1));
36073 if (SWIG_arg_fail(2)) SWIG_fail;
36074 }
36075 {
36076 PyThreadState* __tstate = wxPyBeginAllowThreads();
36077 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36078
36079 wxPyEndAllowThreads(__tstate);
36080 if (PyErr_Occurred()) SWIG_fail;
36081 }
36082 {
36083 resultobj = wxPyMake_wxObject(result, 0);
36084 }
36085 return resultobj;
36086 fail:
36087 return NULL;
36088 }
36089
36090
36091 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36092 PyObject *resultobj;
36093 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36094 wxString *arg2 = 0 ;
36095 int result;
36096 bool temp2 = false ;
36097 PyObject * obj0 = 0 ;
36098 PyObject * obj1 = 0 ;
36099 char *kwnames[] = {
36100 (char *) "self",(char *) "title", NULL
36101 };
36102
36103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36105 if (SWIG_arg_fail(1)) SWIG_fail;
36106 {
36107 arg2 = wxString_in_helper(obj1);
36108 if (arg2 == NULL) SWIG_fail;
36109 temp2 = true;
36110 }
36111 {
36112 PyThreadState* __tstate = wxPyBeginAllowThreads();
36113 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36114
36115 wxPyEndAllowThreads(__tstate);
36116 if (PyErr_Occurred()) SWIG_fail;
36117 }
36118 {
36119 resultobj = SWIG_From_int((int)(result));
36120 }
36121 {
36122 if (temp2)
36123 delete arg2;
36124 }
36125 return resultobj;
36126 fail:
36127 {
36128 if (temp2)
36129 delete arg2;
36130 }
36131 return NULL;
36132 }
36133
36134
36135 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36136 PyObject *resultobj;
36137 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36138 int arg2 ;
36139 bool arg3 ;
36140 PyObject * obj0 = 0 ;
36141 PyObject * obj1 = 0 ;
36142 PyObject * obj2 = 0 ;
36143 char *kwnames[] = {
36144 (char *) "self",(char *) "id",(char *) "enable", NULL
36145 };
36146
36147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36149 if (SWIG_arg_fail(1)) SWIG_fail;
36150 {
36151 arg2 = (int)(SWIG_As_int(obj1));
36152 if (SWIG_arg_fail(2)) SWIG_fail;
36153 }
36154 {
36155 arg3 = (bool)(SWIG_As_bool(obj2));
36156 if (SWIG_arg_fail(3)) SWIG_fail;
36157 }
36158 {
36159 PyThreadState* __tstate = wxPyBeginAllowThreads();
36160 (arg1)->Enable(arg2,arg3);
36161
36162 wxPyEndAllowThreads(__tstate);
36163 if (PyErr_Occurred()) SWIG_fail;
36164 }
36165 Py_INCREF(Py_None); resultobj = Py_None;
36166 return resultobj;
36167 fail:
36168 return NULL;
36169 }
36170
36171
36172 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36173 PyObject *resultobj;
36174 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36175 int arg2 ;
36176 bool arg3 ;
36177 PyObject * obj0 = 0 ;
36178 PyObject * obj1 = 0 ;
36179 PyObject * obj2 = 0 ;
36180 char *kwnames[] = {
36181 (char *) "self",(char *) "id",(char *) "check", NULL
36182 };
36183
36184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36186 if (SWIG_arg_fail(1)) SWIG_fail;
36187 {
36188 arg2 = (int)(SWIG_As_int(obj1));
36189 if (SWIG_arg_fail(2)) SWIG_fail;
36190 }
36191 {
36192 arg3 = (bool)(SWIG_As_bool(obj2));
36193 if (SWIG_arg_fail(3)) SWIG_fail;
36194 }
36195 {
36196 PyThreadState* __tstate = wxPyBeginAllowThreads();
36197 (arg1)->Check(arg2,arg3);
36198
36199 wxPyEndAllowThreads(__tstate);
36200 if (PyErr_Occurred()) SWIG_fail;
36201 }
36202 Py_INCREF(Py_None); resultobj = Py_None;
36203 return resultobj;
36204 fail:
36205 return NULL;
36206 }
36207
36208
36209 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36210 PyObject *resultobj;
36211 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36212 int arg2 ;
36213 bool result;
36214 PyObject * obj0 = 0 ;
36215 PyObject * obj1 = 0 ;
36216 char *kwnames[] = {
36217 (char *) "self",(char *) "id", NULL
36218 };
36219
36220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36222 if (SWIG_arg_fail(1)) SWIG_fail;
36223 {
36224 arg2 = (int)(SWIG_As_int(obj1));
36225 if (SWIG_arg_fail(2)) SWIG_fail;
36226 }
36227 {
36228 PyThreadState* __tstate = wxPyBeginAllowThreads();
36229 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36230
36231 wxPyEndAllowThreads(__tstate);
36232 if (PyErr_Occurred()) SWIG_fail;
36233 }
36234 {
36235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36236 }
36237 return resultobj;
36238 fail:
36239 return NULL;
36240 }
36241
36242
36243 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36244 PyObject *resultobj;
36245 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36246 int arg2 ;
36247 bool result;
36248 PyObject * obj0 = 0 ;
36249 PyObject * obj1 = 0 ;
36250 char *kwnames[] = {
36251 (char *) "self",(char *) "id", NULL
36252 };
36253
36254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36256 if (SWIG_arg_fail(1)) SWIG_fail;
36257 {
36258 arg2 = (int)(SWIG_As_int(obj1));
36259 if (SWIG_arg_fail(2)) SWIG_fail;
36260 }
36261 {
36262 PyThreadState* __tstate = wxPyBeginAllowThreads();
36263 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36264
36265 wxPyEndAllowThreads(__tstate);
36266 if (PyErr_Occurred()) SWIG_fail;
36267 }
36268 {
36269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36270 }
36271 return resultobj;
36272 fail:
36273 return NULL;
36274 }
36275
36276
36277 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36278 PyObject *resultobj;
36279 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36280 int arg2 ;
36281 wxString *arg3 = 0 ;
36282 bool temp3 = false ;
36283 PyObject * obj0 = 0 ;
36284 PyObject * obj1 = 0 ;
36285 PyObject * obj2 = 0 ;
36286 char *kwnames[] = {
36287 (char *) "self",(char *) "id",(char *) "label", NULL
36288 };
36289
36290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36292 if (SWIG_arg_fail(1)) SWIG_fail;
36293 {
36294 arg2 = (int)(SWIG_As_int(obj1));
36295 if (SWIG_arg_fail(2)) SWIG_fail;
36296 }
36297 {
36298 arg3 = wxString_in_helper(obj2);
36299 if (arg3 == NULL) SWIG_fail;
36300 temp3 = true;
36301 }
36302 {
36303 PyThreadState* __tstate = wxPyBeginAllowThreads();
36304 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36305
36306 wxPyEndAllowThreads(__tstate);
36307 if (PyErr_Occurred()) SWIG_fail;
36308 }
36309 Py_INCREF(Py_None); resultobj = Py_None;
36310 {
36311 if (temp3)
36312 delete arg3;
36313 }
36314 return resultobj;
36315 fail:
36316 {
36317 if (temp3)
36318 delete arg3;
36319 }
36320 return NULL;
36321 }
36322
36323
36324 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36325 PyObject *resultobj;
36326 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36327 int arg2 ;
36328 wxString result;
36329 PyObject * obj0 = 0 ;
36330 PyObject * obj1 = 0 ;
36331 char *kwnames[] = {
36332 (char *) "self",(char *) "id", NULL
36333 };
36334
36335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36337 if (SWIG_arg_fail(1)) SWIG_fail;
36338 {
36339 arg2 = (int)(SWIG_As_int(obj1));
36340 if (SWIG_arg_fail(2)) SWIG_fail;
36341 }
36342 {
36343 PyThreadState* __tstate = wxPyBeginAllowThreads();
36344 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36345
36346 wxPyEndAllowThreads(__tstate);
36347 if (PyErr_Occurred()) SWIG_fail;
36348 }
36349 {
36350 #if wxUSE_UNICODE
36351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36352 #else
36353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36354 #endif
36355 }
36356 return resultobj;
36357 fail:
36358 return NULL;
36359 }
36360
36361
36362 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36363 PyObject *resultobj;
36364 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36365 int arg2 ;
36366 wxString *arg3 = 0 ;
36367 bool temp3 = false ;
36368 PyObject * obj0 = 0 ;
36369 PyObject * obj1 = 0 ;
36370 PyObject * obj2 = 0 ;
36371 char *kwnames[] = {
36372 (char *) "self",(char *) "id",(char *) "helpString", NULL
36373 };
36374
36375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36377 if (SWIG_arg_fail(1)) SWIG_fail;
36378 {
36379 arg2 = (int)(SWIG_As_int(obj1));
36380 if (SWIG_arg_fail(2)) SWIG_fail;
36381 }
36382 {
36383 arg3 = wxString_in_helper(obj2);
36384 if (arg3 == NULL) SWIG_fail;
36385 temp3 = true;
36386 }
36387 {
36388 PyThreadState* __tstate = wxPyBeginAllowThreads();
36389 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36390
36391 wxPyEndAllowThreads(__tstate);
36392 if (PyErr_Occurred()) SWIG_fail;
36393 }
36394 Py_INCREF(Py_None); resultobj = Py_None;
36395 {
36396 if (temp3)
36397 delete arg3;
36398 }
36399 return resultobj;
36400 fail:
36401 {
36402 if (temp3)
36403 delete arg3;
36404 }
36405 return NULL;
36406 }
36407
36408
36409 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36410 PyObject *resultobj;
36411 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36412 int arg2 ;
36413 wxString result;
36414 PyObject * obj0 = 0 ;
36415 PyObject * obj1 = 0 ;
36416 char *kwnames[] = {
36417 (char *) "self",(char *) "id", NULL
36418 };
36419
36420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36422 if (SWIG_arg_fail(1)) SWIG_fail;
36423 {
36424 arg2 = (int)(SWIG_As_int(obj1));
36425 if (SWIG_arg_fail(2)) SWIG_fail;
36426 }
36427 {
36428 PyThreadState* __tstate = wxPyBeginAllowThreads();
36429 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36430
36431 wxPyEndAllowThreads(__tstate);
36432 if (PyErr_Occurred()) SWIG_fail;
36433 }
36434 {
36435 #if wxUSE_UNICODE
36436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36437 #else
36438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36439 #endif
36440 }
36441 return resultobj;
36442 fail:
36443 return NULL;
36444 }
36445
36446
36447 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36448 PyObject *resultobj;
36449 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36450 wxFrame *result;
36451 PyObject * obj0 = 0 ;
36452 char *kwnames[] = {
36453 (char *) "self", NULL
36454 };
36455
36456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36458 if (SWIG_arg_fail(1)) SWIG_fail;
36459 {
36460 PyThreadState* __tstate = wxPyBeginAllowThreads();
36461 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36462
36463 wxPyEndAllowThreads(__tstate);
36464 if (PyErr_Occurred()) SWIG_fail;
36465 }
36466 {
36467 resultobj = wxPyMake_wxObject(result, 0);
36468 }
36469 return resultobj;
36470 fail:
36471 return NULL;
36472 }
36473
36474
36475 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36476 PyObject *resultobj;
36477 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36478 bool result;
36479 PyObject * obj0 = 0 ;
36480 char *kwnames[] = {
36481 (char *) "self", NULL
36482 };
36483
36484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36486 if (SWIG_arg_fail(1)) SWIG_fail;
36487 {
36488 PyThreadState* __tstate = wxPyBeginAllowThreads();
36489 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36490
36491 wxPyEndAllowThreads(__tstate);
36492 if (PyErr_Occurred()) SWIG_fail;
36493 }
36494 {
36495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36496 }
36497 return resultobj;
36498 fail:
36499 return NULL;
36500 }
36501
36502
36503 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36504 PyObject *resultobj;
36505 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36506 wxFrame *arg2 = (wxFrame *) 0 ;
36507 PyObject * obj0 = 0 ;
36508 PyObject * obj1 = 0 ;
36509 char *kwnames[] = {
36510 (char *) "self",(char *) "frame", NULL
36511 };
36512
36513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36515 if (SWIG_arg_fail(1)) SWIG_fail;
36516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36517 if (SWIG_arg_fail(2)) SWIG_fail;
36518 {
36519 PyThreadState* __tstate = wxPyBeginAllowThreads();
36520 (arg1)->Attach(arg2);
36521
36522 wxPyEndAllowThreads(__tstate);
36523 if (PyErr_Occurred()) SWIG_fail;
36524 }
36525 Py_INCREF(Py_None); resultobj = Py_None;
36526 return resultobj;
36527 fail:
36528 return NULL;
36529 }
36530
36531
36532 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36533 PyObject *resultobj;
36534 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36535 PyObject * obj0 = 0 ;
36536 char *kwnames[] = {
36537 (char *) "self", NULL
36538 };
36539
36540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36542 if (SWIG_arg_fail(1)) SWIG_fail;
36543 {
36544 PyThreadState* __tstate = wxPyBeginAllowThreads();
36545 (arg1)->Detach();
36546
36547 wxPyEndAllowThreads(__tstate);
36548 if (PyErr_Occurred()) SWIG_fail;
36549 }
36550 Py_INCREF(Py_None); resultobj = Py_None;
36551 return resultobj;
36552 fail:
36553 return NULL;
36554 }
36555
36556
36557 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36558 PyObject *resultobj;
36559 bool arg1 ;
36560 PyObject * obj0 = 0 ;
36561 char *kwnames[] = {
36562 (char *) "enable", NULL
36563 };
36564
36565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36566 {
36567 arg1 = (bool)(SWIG_As_bool(obj0));
36568 if (SWIG_arg_fail(1)) SWIG_fail;
36569 }
36570 {
36571 PyThreadState* __tstate = wxPyBeginAllowThreads();
36572 MenuBar_SetAutoWindowMenu(arg1);
36573
36574 wxPyEndAllowThreads(__tstate);
36575 if (PyErr_Occurred()) SWIG_fail;
36576 }
36577 Py_INCREF(Py_None); resultobj = Py_None;
36578 return resultobj;
36579 fail:
36580 return NULL;
36581 }
36582
36583
36584 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36585 PyObject *resultobj;
36586 bool result;
36587 char *kwnames[] = {
36588 NULL
36589 };
36590
36591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36592 {
36593 PyThreadState* __tstate = wxPyBeginAllowThreads();
36594 result = (bool)MenuBar_GetAutoWindowMenu();
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 * MenuBar_swigregister(PyObject *, PyObject *args) {
36609 PyObject *obj;
36610 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36611 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36612 Py_INCREF(obj);
36613 return Py_BuildValue((char *)"");
36614 }
36615 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36616 PyObject *resultobj;
36617 wxMenu *arg1 = (wxMenu *) NULL ;
36618 int arg2 = (int) wxID_ANY ;
36619 wxString const &arg3_defvalue = wxPyEmptyString ;
36620 wxString *arg3 = (wxString *) &arg3_defvalue ;
36621 wxString const &arg4_defvalue = wxPyEmptyString ;
36622 wxString *arg4 = (wxString *) &arg4_defvalue ;
36623 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36624 wxMenu *arg6 = (wxMenu *) NULL ;
36625 wxMenuItem *result;
36626 bool temp3 = false ;
36627 bool temp4 = false ;
36628 PyObject * obj0 = 0 ;
36629 PyObject * obj1 = 0 ;
36630 PyObject * obj2 = 0 ;
36631 PyObject * obj3 = 0 ;
36632 PyObject * obj4 = 0 ;
36633 PyObject * obj5 = 0 ;
36634 char *kwnames[] = {
36635 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36636 };
36637
36638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36639 if (obj0) {
36640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36641 if (SWIG_arg_fail(1)) SWIG_fail;
36642 }
36643 if (obj1) {
36644 {
36645 arg2 = (int)(SWIG_As_int(obj1));
36646 if (SWIG_arg_fail(2)) SWIG_fail;
36647 }
36648 }
36649 if (obj2) {
36650 {
36651 arg3 = wxString_in_helper(obj2);
36652 if (arg3 == NULL) SWIG_fail;
36653 temp3 = true;
36654 }
36655 }
36656 if (obj3) {
36657 {
36658 arg4 = wxString_in_helper(obj3);
36659 if (arg4 == NULL) SWIG_fail;
36660 temp4 = true;
36661 }
36662 }
36663 if (obj4) {
36664 {
36665 arg5 = (wxItemKind)(SWIG_As_int(obj4));
36666 if (SWIG_arg_fail(5)) SWIG_fail;
36667 }
36668 }
36669 if (obj5) {
36670 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36671 if (SWIG_arg_fail(6)) SWIG_fail;
36672 }
36673 {
36674 PyThreadState* __tstate = wxPyBeginAllowThreads();
36675 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36676
36677 wxPyEndAllowThreads(__tstate);
36678 if (PyErr_Occurred()) SWIG_fail;
36679 }
36680 {
36681 resultobj = wxPyMake_wxObject(result, 1);
36682 }
36683 {
36684 if (temp3)
36685 delete arg3;
36686 }
36687 {
36688 if (temp4)
36689 delete arg4;
36690 }
36691 return resultobj;
36692 fail:
36693 {
36694 if (temp3)
36695 delete arg3;
36696 }
36697 {
36698 if (temp4)
36699 delete arg4;
36700 }
36701 return NULL;
36702 }
36703
36704
36705 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36706 PyObject *resultobj;
36707 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36708 wxMenu *result;
36709 PyObject * obj0 = 0 ;
36710 char *kwnames[] = {
36711 (char *) "self", NULL
36712 };
36713
36714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36716 if (SWIG_arg_fail(1)) SWIG_fail;
36717 {
36718 PyThreadState* __tstate = wxPyBeginAllowThreads();
36719 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36720
36721 wxPyEndAllowThreads(__tstate);
36722 if (PyErr_Occurred()) SWIG_fail;
36723 }
36724 {
36725 resultobj = wxPyMake_wxObject(result, 0);
36726 }
36727 return resultobj;
36728 fail:
36729 return NULL;
36730 }
36731
36732
36733 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36734 PyObject *resultobj;
36735 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36736 wxMenu *arg2 = (wxMenu *) 0 ;
36737 PyObject * obj0 = 0 ;
36738 PyObject * obj1 = 0 ;
36739 char *kwnames[] = {
36740 (char *) "self",(char *) "menu", NULL
36741 };
36742
36743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36745 if (SWIG_arg_fail(1)) SWIG_fail;
36746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36747 if (SWIG_arg_fail(2)) SWIG_fail;
36748 {
36749 PyThreadState* __tstate = wxPyBeginAllowThreads();
36750 (arg1)->SetMenu(arg2);
36751
36752 wxPyEndAllowThreads(__tstate);
36753 if (PyErr_Occurred()) SWIG_fail;
36754 }
36755 Py_INCREF(Py_None); resultobj = Py_None;
36756 return resultobj;
36757 fail:
36758 return NULL;
36759 }
36760
36761
36762 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36763 PyObject *resultobj;
36764 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36765 int arg2 ;
36766 PyObject * obj0 = 0 ;
36767 PyObject * obj1 = 0 ;
36768 char *kwnames[] = {
36769 (char *) "self",(char *) "id", NULL
36770 };
36771
36772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36774 if (SWIG_arg_fail(1)) SWIG_fail;
36775 {
36776 arg2 = (int)(SWIG_As_int(obj1));
36777 if (SWIG_arg_fail(2)) SWIG_fail;
36778 }
36779 {
36780 PyThreadState* __tstate = wxPyBeginAllowThreads();
36781 (arg1)->SetId(arg2);
36782
36783 wxPyEndAllowThreads(__tstate);
36784 if (PyErr_Occurred()) SWIG_fail;
36785 }
36786 Py_INCREF(Py_None); resultobj = Py_None;
36787 return resultobj;
36788 fail:
36789 return NULL;
36790 }
36791
36792
36793 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36794 PyObject *resultobj;
36795 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36796 int result;
36797 PyObject * obj0 = 0 ;
36798 char *kwnames[] = {
36799 (char *) "self", NULL
36800 };
36801
36802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36804 if (SWIG_arg_fail(1)) SWIG_fail;
36805 {
36806 PyThreadState* __tstate = wxPyBeginAllowThreads();
36807 result = (int)((wxMenuItem const *)arg1)->GetId();
36808
36809 wxPyEndAllowThreads(__tstate);
36810 if (PyErr_Occurred()) SWIG_fail;
36811 }
36812 {
36813 resultobj = SWIG_From_int((int)(result));
36814 }
36815 return resultobj;
36816 fail:
36817 return NULL;
36818 }
36819
36820
36821 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36822 PyObject *resultobj;
36823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36824 bool result;
36825 PyObject * obj0 = 0 ;
36826 char *kwnames[] = {
36827 (char *) "self", NULL
36828 };
36829
36830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36832 if (SWIG_arg_fail(1)) SWIG_fail;
36833 {
36834 PyThreadState* __tstate = wxPyBeginAllowThreads();
36835 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36836
36837 wxPyEndAllowThreads(__tstate);
36838 if (PyErr_Occurred()) SWIG_fail;
36839 }
36840 {
36841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36842 }
36843 return resultobj;
36844 fail:
36845 return NULL;
36846 }
36847
36848
36849 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36850 PyObject *resultobj;
36851 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36852 wxString *arg2 = 0 ;
36853 bool temp2 = false ;
36854 PyObject * obj0 = 0 ;
36855 PyObject * obj1 = 0 ;
36856 char *kwnames[] = {
36857 (char *) "self",(char *) "str", NULL
36858 };
36859
36860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36862 if (SWIG_arg_fail(1)) SWIG_fail;
36863 {
36864 arg2 = wxString_in_helper(obj1);
36865 if (arg2 == NULL) SWIG_fail;
36866 temp2 = true;
36867 }
36868 {
36869 PyThreadState* __tstate = wxPyBeginAllowThreads();
36870 (arg1)->SetText((wxString const &)*arg2);
36871
36872 wxPyEndAllowThreads(__tstate);
36873 if (PyErr_Occurred()) SWIG_fail;
36874 }
36875 Py_INCREF(Py_None); resultobj = Py_None;
36876 {
36877 if (temp2)
36878 delete arg2;
36879 }
36880 return resultobj;
36881 fail:
36882 {
36883 if (temp2)
36884 delete arg2;
36885 }
36886 return NULL;
36887 }
36888
36889
36890 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36891 PyObject *resultobj;
36892 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36893 wxString result;
36894 PyObject * obj0 = 0 ;
36895 char *kwnames[] = {
36896 (char *) "self", NULL
36897 };
36898
36899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36901 if (SWIG_arg_fail(1)) SWIG_fail;
36902 {
36903 PyThreadState* __tstate = wxPyBeginAllowThreads();
36904 result = ((wxMenuItem const *)arg1)->GetLabel();
36905
36906 wxPyEndAllowThreads(__tstate);
36907 if (PyErr_Occurred()) SWIG_fail;
36908 }
36909 {
36910 #if wxUSE_UNICODE
36911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36912 #else
36913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36914 #endif
36915 }
36916 return resultobj;
36917 fail:
36918 return NULL;
36919 }
36920
36921
36922 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36923 PyObject *resultobj;
36924 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36925 wxString *result;
36926 PyObject * obj0 = 0 ;
36927 char *kwnames[] = {
36928 (char *) "self", NULL
36929 };
36930
36931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36933 if (SWIG_arg_fail(1)) SWIG_fail;
36934 {
36935 PyThreadState* __tstate = wxPyBeginAllowThreads();
36936 {
36937 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36938 result = (wxString *) &_result_ref;
36939 }
36940
36941 wxPyEndAllowThreads(__tstate);
36942 if (PyErr_Occurred()) SWIG_fail;
36943 }
36944 {
36945 #if wxUSE_UNICODE
36946 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36947 #else
36948 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36949 #endif
36950 }
36951 return resultobj;
36952 fail:
36953 return NULL;
36954 }
36955
36956
36957 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36958 PyObject *resultobj;
36959 wxString *arg1 = 0 ;
36960 wxString result;
36961 bool temp1 = false ;
36962 PyObject * obj0 = 0 ;
36963 char *kwnames[] = {
36964 (char *) "text", NULL
36965 };
36966
36967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36968 {
36969 arg1 = wxString_in_helper(obj0);
36970 if (arg1 == NULL) SWIG_fail;
36971 temp1 = true;
36972 }
36973 {
36974 PyThreadState* __tstate = wxPyBeginAllowThreads();
36975 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36976
36977 wxPyEndAllowThreads(__tstate);
36978 if (PyErr_Occurred()) SWIG_fail;
36979 }
36980 {
36981 #if wxUSE_UNICODE
36982 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36983 #else
36984 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36985 #endif
36986 }
36987 {
36988 if (temp1)
36989 delete arg1;
36990 }
36991 return resultobj;
36992 fail:
36993 {
36994 if (temp1)
36995 delete arg1;
36996 }
36997 return NULL;
36998 }
36999
37000
37001 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37002 PyObject *resultobj;
37003 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37004 wxItemKind result;
37005 PyObject * obj0 = 0 ;
37006 char *kwnames[] = {
37007 (char *) "self", NULL
37008 };
37009
37010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
37011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37012 if (SWIG_arg_fail(1)) SWIG_fail;
37013 {
37014 PyThreadState* __tstate = wxPyBeginAllowThreads();
37015 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
37016
37017 wxPyEndAllowThreads(__tstate);
37018 if (PyErr_Occurred()) SWIG_fail;
37019 }
37020 resultobj = SWIG_From_int((result));
37021 return resultobj;
37022 fail:
37023 return NULL;
37024 }
37025
37026
37027 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37028 PyObject *resultobj;
37029 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37030 wxItemKind arg2 ;
37031 PyObject * obj0 = 0 ;
37032 PyObject * obj1 = 0 ;
37033 char *kwnames[] = {
37034 (char *) "self",(char *) "kind", NULL
37035 };
37036
37037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
37038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37039 if (SWIG_arg_fail(1)) SWIG_fail;
37040 {
37041 arg2 = (wxItemKind)(SWIG_As_int(obj1));
37042 if (SWIG_arg_fail(2)) SWIG_fail;
37043 }
37044 {
37045 PyThreadState* __tstate = wxPyBeginAllowThreads();
37046 (arg1)->SetKind((wxItemKind )arg2);
37047
37048 wxPyEndAllowThreads(__tstate);
37049 if (PyErr_Occurred()) SWIG_fail;
37050 }
37051 Py_INCREF(Py_None); resultobj = Py_None;
37052 return resultobj;
37053 fail:
37054 return NULL;
37055 }
37056
37057
37058 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37059 PyObject *resultobj;
37060 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37061 bool arg2 ;
37062 PyObject * obj0 = 0 ;
37063 PyObject * obj1 = 0 ;
37064 char *kwnames[] = {
37065 (char *) "self",(char *) "checkable", NULL
37066 };
37067
37068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
37069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37070 if (SWIG_arg_fail(1)) SWIG_fail;
37071 {
37072 arg2 = (bool)(SWIG_As_bool(obj1));
37073 if (SWIG_arg_fail(2)) SWIG_fail;
37074 }
37075 {
37076 PyThreadState* __tstate = wxPyBeginAllowThreads();
37077 (arg1)->SetCheckable(arg2);
37078
37079 wxPyEndAllowThreads(__tstate);
37080 if (PyErr_Occurred()) SWIG_fail;
37081 }
37082 Py_INCREF(Py_None); resultobj = Py_None;
37083 return resultobj;
37084 fail:
37085 return NULL;
37086 }
37087
37088
37089 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37090 PyObject *resultobj;
37091 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37092 bool result;
37093 PyObject * obj0 = 0 ;
37094 char *kwnames[] = {
37095 (char *) "self", NULL
37096 };
37097
37098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
37099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37100 if (SWIG_arg_fail(1)) SWIG_fail;
37101 {
37102 PyThreadState* __tstate = wxPyBeginAllowThreads();
37103 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37104
37105 wxPyEndAllowThreads(__tstate);
37106 if (PyErr_Occurred()) SWIG_fail;
37107 }
37108 {
37109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37110 }
37111 return resultobj;
37112 fail:
37113 return NULL;
37114 }
37115
37116
37117 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37118 PyObject *resultobj;
37119 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37120 bool result;
37121 PyObject * obj0 = 0 ;
37122 char *kwnames[] = {
37123 (char *) "self", NULL
37124 };
37125
37126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37128 if (SWIG_arg_fail(1)) SWIG_fail;
37129 {
37130 PyThreadState* __tstate = wxPyBeginAllowThreads();
37131 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37132
37133 wxPyEndAllowThreads(__tstate);
37134 if (PyErr_Occurred()) SWIG_fail;
37135 }
37136 {
37137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37138 }
37139 return resultobj;
37140 fail:
37141 return NULL;
37142 }
37143
37144
37145 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37146 PyObject *resultobj;
37147 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37148 wxMenu *arg2 = (wxMenu *) 0 ;
37149 PyObject * obj0 = 0 ;
37150 PyObject * obj1 = 0 ;
37151 char *kwnames[] = {
37152 (char *) "self",(char *) "menu", NULL
37153 };
37154
37155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37157 if (SWIG_arg_fail(1)) SWIG_fail;
37158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37159 if (SWIG_arg_fail(2)) SWIG_fail;
37160 {
37161 PyThreadState* __tstate = wxPyBeginAllowThreads();
37162 (arg1)->SetSubMenu(arg2);
37163
37164 wxPyEndAllowThreads(__tstate);
37165 if (PyErr_Occurred()) SWIG_fail;
37166 }
37167 Py_INCREF(Py_None); resultobj = Py_None;
37168 return resultobj;
37169 fail:
37170 return NULL;
37171 }
37172
37173
37174 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37175 PyObject *resultobj;
37176 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37177 wxMenu *result;
37178 PyObject * obj0 = 0 ;
37179 char *kwnames[] = {
37180 (char *) "self", NULL
37181 };
37182
37183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37185 if (SWIG_arg_fail(1)) SWIG_fail;
37186 {
37187 PyThreadState* __tstate = wxPyBeginAllowThreads();
37188 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37189
37190 wxPyEndAllowThreads(__tstate);
37191 if (PyErr_Occurred()) SWIG_fail;
37192 }
37193 {
37194 resultobj = wxPyMake_wxObject(result, 0);
37195 }
37196 return resultobj;
37197 fail:
37198 return NULL;
37199 }
37200
37201
37202 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37203 PyObject *resultobj;
37204 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37205 bool arg2 = (bool) true ;
37206 PyObject * obj0 = 0 ;
37207 PyObject * obj1 = 0 ;
37208 char *kwnames[] = {
37209 (char *) "self",(char *) "enable", NULL
37210 };
37211
37212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37214 if (SWIG_arg_fail(1)) SWIG_fail;
37215 if (obj1) {
37216 {
37217 arg2 = (bool)(SWIG_As_bool(obj1));
37218 if (SWIG_arg_fail(2)) SWIG_fail;
37219 }
37220 }
37221 {
37222 PyThreadState* __tstate = wxPyBeginAllowThreads();
37223 (arg1)->Enable(arg2);
37224
37225 wxPyEndAllowThreads(__tstate);
37226 if (PyErr_Occurred()) SWIG_fail;
37227 }
37228 Py_INCREF(Py_None); resultobj = Py_None;
37229 return resultobj;
37230 fail:
37231 return NULL;
37232 }
37233
37234
37235 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37236 PyObject *resultobj;
37237 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37238 bool result;
37239 PyObject * obj0 = 0 ;
37240 char *kwnames[] = {
37241 (char *) "self", NULL
37242 };
37243
37244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37246 if (SWIG_arg_fail(1)) SWIG_fail;
37247 {
37248 PyThreadState* __tstate = wxPyBeginAllowThreads();
37249 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37250
37251 wxPyEndAllowThreads(__tstate);
37252 if (PyErr_Occurred()) SWIG_fail;
37253 }
37254 {
37255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37256 }
37257 return resultobj;
37258 fail:
37259 return NULL;
37260 }
37261
37262
37263 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37264 PyObject *resultobj;
37265 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37266 bool arg2 = (bool) true ;
37267 PyObject * obj0 = 0 ;
37268 PyObject * obj1 = 0 ;
37269 char *kwnames[] = {
37270 (char *) "self",(char *) "check", NULL
37271 };
37272
37273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
37274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37275 if (SWIG_arg_fail(1)) SWIG_fail;
37276 if (obj1) {
37277 {
37278 arg2 = (bool)(SWIG_As_bool(obj1));
37279 if (SWIG_arg_fail(2)) SWIG_fail;
37280 }
37281 }
37282 {
37283 PyThreadState* __tstate = wxPyBeginAllowThreads();
37284 (arg1)->Check(arg2);
37285
37286 wxPyEndAllowThreads(__tstate);
37287 if (PyErr_Occurred()) SWIG_fail;
37288 }
37289 Py_INCREF(Py_None); resultobj = Py_None;
37290 return resultobj;
37291 fail:
37292 return NULL;
37293 }
37294
37295
37296 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37297 PyObject *resultobj;
37298 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37299 bool result;
37300 PyObject * obj0 = 0 ;
37301 char *kwnames[] = {
37302 (char *) "self", NULL
37303 };
37304
37305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37307 if (SWIG_arg_fail(1)) SWIG_fail;
37308 {
37309 PyThreadState* __tstate = wxPyBeginAllowThreads();
37310 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37311
37312 wxPyEndAllowThreads(__tstate);
37313 if (PyErr_Occurred()) SWIG_fail;
37314 }
37315 {
37316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37317 }
37318 return resultobj;
37319 fail:
37320 return NULL;
37321 }
37322
37323
37324 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37325 PyObject *resultobj;
37326 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37327 PyObject * obj0 = 0 ;
37328 char *kwnames[] = {
37329 (char *) "self", NULL
37330 };
37331
37332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37334 if (SWIG_arg_fail(1)) SWIG_fail;
37335 {
37336 PyThreadState* __tstate = wxPyBeginAllowThreads();
37337 (arg1)->Toggle();
37338
37339 wxPyEndAllowThreads(__tstate);
37340 if (PyErr_Occurred()) SWIG_fail;
37341 }
37342 Py_INCREF(Py_None); resultobj = Py_None;
37343 return resultobj;
37344 fail:
37345 return NULL;
37346 }
37347
37348
37349 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37350 PyObject *resultobj;
37351 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37352 wxString *arg2 = 0 ;
37353 bool temp2 = false ;
37354 PyObject * obj0 = 0 ;
37355 PyObject * obj1 = 0 ;
37356 char *kwnames[] = {
37357 (char *) "self",(char *) "str", NULL
37358 };
37359
37360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37362 if (SWIG_arg_fail(1)) SWIG_fail;
37363 {
37364 arg2 = wxString_in_helper(obj1);
37365 if (arg2 == NULL) SWIG_fail;
37366 temp2 = true;
37367 }
37368 {
37369 PyThreadState* __tstate = wxPyBeginAllowThreads();
37370 (arg1)->SetHelp((wxString const &)*arg2);
37371
37372 wxPyEndAllowThreads(__tstate);
37373 if (PyErr_Occurred()) SWIG_fail;
37374 }
37375 Py_INCREF(Py_None); resultobj = Py_None;
37376 {
37377 if (temp2)
37378 delete arg2;
37379 }
37380 return resultobj;
37381 fail:
37382 {
37383 if (temp2)
37384 delete arg2;
37385 }
37386 return NULL;
37387 }
37388
37389
37390 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37391 PyObject *resultobj;
37392 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37393 wxString *result;
37394 PyObject * obj0 = 0 ;
37395 char *kwnames[] = {
37396 (char *) "self", NULL
37397 };
37398
37399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37401 if (SWIG_arg_fail(1)) SWIG_fail;
37402 {
37403 PyThreadState* __tstate = wxPyBeginAllowThreads();
37404 {
37405 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37406 result = (wxString *) &_result_ref;
37407 }
37408
37409 wxPyEndAllowThreads(__tstate);
37410 if (PyErr_Occurred()) SWIG_fail;
37411 }
37412 {
37413 #if wxUSE_UNICODE
37414 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37415 #else
37416 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37417 #endif
37418 }
37419 return resultobj;
37420 fail:
37421 return NULL;
37422 }
37423
37424
37425 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37426 PyObject *resultobj;
37427 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37428 wxAcceleratorEntry *result;
37429 PyObject * obj0 = 0 ;
37430 char *kwnames[] = {
37431 (char *) "self", NULL
37432 };
37433
37434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37436 if (SWIG_arg_fail(1)) SWIG_fail;
37437 {
37438 PyThreadState* __tstate = wxPyBeginAllowThreads();
37439 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37440
37441 wxPyEndAllowThreads(__tstate);
37442 if (PyErr_Occurred()) SWIG_fail;
37443 }
37444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37445 return resultobj;
37446 fail:
37447 return NULL;
37448 }
37449
37450
37451 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37452 PyObject *resultobj;
37453 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37454 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37455 PyObject * obj0 = 0 ;
37456 PyObject * obj1 = 0 ;
37457 char *kwnames[] = {
37458 (char *) "self",(char *) "accel", NULL
37459 };
37460
37461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37463 if (SWIG_arg_fail(1)) SWIG_fail;
37464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37465 if (SWIG_arg_fail(2)) SWIG_fail;
37466 {
37467 PyThreadState* __tstate = wxPyBeginAllowThreads();
37468 (arg1)->SetAccel(arg2);
37469
37470 wxPyEndAllowThreads(__tstate);
37471 if (PyErr_Occurred()) SWIG_fail;
37472 }
37473 Py_INCREF(Py_None); resultobj = Py_None;
37474 return resultobj;
37475 fail:
37476 return NULL;
37477 }
37478
37479
37480 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37481 PyObject *resultobj;
37482 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37483 wxBitmap *arg2 = 0 ;
37484 PyObject * obj0 = 0 ;
37485 PyObject * obj1 = 0 ;
37486 char *kwnames[] = {
37487 (char *) "self",(char *) "bitmap", NULL
37488 };
37489
37490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37492 if (SWIG_arg_fail(1)) SWIG_fail;
37493 {
37494 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37495 if (SWIG_arg_fail(2)) SWIG_fail;
37496 if (arg2 == NULL) {
37497 SWIG_null_ref("wxBitmap");
37498 }
37499 if (SWIG_arg_fail(2)) SWIG_fail;
37500 }
37501 {
37502 PyThreadState* __tstate = wxPyBeginAllowThreads();
37503 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37504
37505 wxPyEndAllowThreads(__tstate);
37506 if (PyErr_Occurred()) SWIG_fail;
37507 }
37508 Py_INCREF(Py_None); resultobj = Py_None;
37509 return resultobj;
37510 fail:
37511 return NULL;
37512 }
37513
37514
37515 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37516 PyObject *resultobj;
37517 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37518 wxBitmap *result;
37519 PyObject * obj0 = 0 ;
37520 char *kwnames[] = {
37521 (char *) "self", NULL
37522 };
37523
37524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37526 if (SWIG_arg_fail(1)) SWIG_fail;
37527 {
37528 PyThreadState* __tstate = wxPyBeginAllowThreads();
37529 {
37530 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37531 result = (wxBitmap *) &_result_ref;
37532 }
37533
37534 wxPyEndAllowThreads(__tstate);
37535 if (PyErr_Occurred()) SWIG_fail;
37536 }
37537 {
37538 wxBitmap* resultptr = new wxBitmap(*result);
37539 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37540 }
37541 return resultobj;
37542 fail:
37543 return NULL;
37544 }
37545
37546
37547 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37548 PyObject *resultobj;
37549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37550 wxFont *arg2 = 0 ;
37551 PyObject * obj0 = 0 ;
37552 PyObject * obj1 = 0 ;
37553 char *kwnames[] = {
37554 (char *) "self",(char *) "font", NULL
37555 };
37556
37557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37559 if (SWIG_arg_fail(1)) SWIG_fail;
37560 {
37561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37562 if (SWIG_arg_fail(2)) SWIG_fail;
37563 if (arg2 == NULL) {
37564 SWIG_null_ref("wxFont");
37565 }
37566 if (SWIG_arg_fail(2)) SWIG_fail;
37567 }
37568 {
37569 PyThreadState* __tstate = wxPyBeginAllowThreads();
37570 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
37571
37572 wxPyEndAllowThreads(__tstate);
37573 if (PyErr_Occurred()) SWIG_fail;
37574 }
37575 Py_INCREF(Py_None); resultobj = Py_None;
37576 return resultobj;
37577 fail:
37578 return NULL;
37579 }
37580
37581
37582 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37583 PyObject *resultobj;
37584 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37585 wxFont result;
37586 PyObject * obj0 = 0 ;
37587 char *kwnames[] = {
37588 (char *) "self", NULL
37589 };
37590
37591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37593 if (SWIG_arg_fail(1)) SWIG_fail;
37594 {
37595 PyThreadState* __tstate = wxPyBeginAllowThreads();
37596 result = wxMenuItem_GetFont(arg1);
37597
37598 wxPyEndAllowThreads(__tstate);
37599 if (PyErr_Occurred()) SWIG_fail;
37600 }
37601 {
37602 wxFont * resultptr;
37603 resultptr = new wxFont((wxFont &)(result));
37604 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37605 }
37606 return resultobj;
37607 fail:
37608 return NULL;
37609 }
37610
37611
37612 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37613 PyObject *resultobj;
37614 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37615 wxColour *arg2 = 0 ;
37616 wxColour temp2 ;
37617 PyObject * obj0 = 0 ;
37618 PyObject * obj1 = 0 ;
37619 char *kwnames[] = {
37620 (char *) "self",(char *) "colText", NULL
37621 };
37622
37623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37625 if (SWIG_arg_fail(1)) SWIG_fail;
37626 {
37627 arg2 = &temp2;
37628 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37629 }
37630 {
37631 PyThreadState* __tstate = wxPyBeginAllowThreads();
37632 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
37633
37634 wxPyEndAllowThreads(__tstate);
37635 if (PyErr_Occurred()) SWIG_fail;
37636 }
37637 Py_INCREF(Py_None); resultobj = Py_None;
37638 return resultobj;
37639 fail:
37640 return NULL;
37641 }
37642
37643
37644 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37645 PyObject *resultobj;
37646 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37647 wxColour result;
37648 PyObject * obj0 = 0 ;
37649 char *kwnames[] = {
37650 (char *) "self", NULL
37651 };
37652
37653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37655 if (SWIG_arg_fail(1)) SWIG_fail;
37656 {
37657 PyThreadState* __tstate = wxPyBeginAllowThreads();
37658 result = wxMenuItem_GetTextColour(arg1);
37659
37660 wxPyEndAllowThreads(__tstate);
37661 if (PyErr_Occurred()) SWIG_fail;
37662 }
37663 {
37664 wxColour * resultptr;
37665 resultptr = new wxColour((wxColour &)(result));
37666 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37667 }
37668 return resultobj;
37669 fail:
37670 return NULL;
37671 }
37672
37673
37674 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37675 PyObject *resultobj;
37676 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37677 wxColour *arg2 = 0 ;
37678 wxColour temp2 ;
37679 PyObject * obj0 = 0 ;
37680 PyObject * obj1 = 0 ;
37681 char *kwnames[] = {
37682 (char *) "self",(char *) "colBack", NULL
37683 };
37684
37685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37687 if (SWIG_arg_fail(1)) SWIG_fail;
37688 {
37689 arg2 = &temp2;
37690 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37691 }
37692 {
37693 PyThreadState* __tstate = wxPyBeginAllowThreads();
37694 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
37695
37696 wxPyEndAllowThreads(__tstate);
37697 if (PyErr_Occurred()) SWIG_fail;
37698 }
37699 Py_INCREF(Py_None); resultobj = Py_None;
37700 return resultobj;
37701 fail:
37702 return NULL;
37703 }
37704
37705
37706 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37707 PyObject *resultobj;
37708 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37709 wxColour result;
37710 PyObject * obj0 = 0 ;
37711 char *kwnames[] = {
37712 (char *) "self", NULL
37713 };
37714
37715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37717 if (SWIG_arg_fail(1)) SWIG_fail;
37718 {
37719 PyThreadState* __tstate = wxPyBeginAllowThreads();
37720 result = wxMenuItem_GetBackgroundColour(arg1);
37721
37722 wxPyEndAllowThreads(__tstate);
37723 if (PyErr_Occurred()) SWIG_fail;
37724 }
37725 {
37726 wxColour * resultptr;
37727 resultptr = new wxColour((wxColour &)(result));
37728 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37729 }
37730 return resultobj;
37731 fail:
37732 return NULL;
37733 }
37734
37735
37736 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37737 PyObject *resultobj;
37738 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37739 wxBitmap *arg2 = 0 ;
37740 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37741 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37742 PyObject * obj0 = 0 ;
37743 PyObject * obj1 = 0 ;
37744 PyObject * obj2 = 0 ;
37745 char *kwnames[] = {
37746 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37747 };
37748
37749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37751 if (SWIG_arg_fail(1)) SWIG_fail;
37752 {
37753 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37754 if (SWIG_arg_fail(2)) SWIG_fail;
37755 if (arg2 == NULL) {
37756 SWIG_null_ref("wxBitmap");
37757 }
37758 if (SWIG_arg_fail(2)) SWIG_fail;
37759 }
37760 if (obj2) {
37761 {
37762 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37763 if (SWIG_arg_fail(3)) SWIG_fail;
37764 if (arg3 == NULL) {
37765 SWIG_null_ref("wxBitmap");
37766 }
37767 if (SWIG_arg_fail(3)) SWIG_fail;
37768 }
37769 }
37770 {
37771 PyThreadState* __tstate = wxPyBeginAllowThreads();
37772 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37773
37774 wxPyEndAllowThreads(__tstate);
37775 if (PyErr_Occurred()) SWIG_fail;
37776 }
37777 Py_INCREF(Py_None); resultobj = Py_None;
37778 return resultobj;
37779 fail:
37780 return NULL;
37781 }
37782
37783
37784 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37785 PyObject *resultobj;
37786 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37787 wxBitmap *arg2 = 0 ;
37788 PyObject * obj0 = 0 ;
37789 PyObject * obj1 = 0 ;
37790 char *kwnames[] = {
37791 (char *) "self",(char *) "bmpDisabled", NULL
37792 };
37793
37794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37796 if (SWIG_arg_fail(1)) SWIG_fail;
37797 {
37798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37799 if (SWIG_arg_fail(2)) SWIG_fail;
37800 if (arg2 == NULL) {
37801 SWIG_null_ref("wxBitmap");
37802 }
37803 if (SWIG_arg_fail(2)) SWIG_fail;
37804 }
37805 {
37806 PyThreadState* __tstate = wxPyBeginAllowThreads();
37807 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37808
37809 wxPyEndAllowThreads(__tstate);
37810 if (PyErr_Occurred()) SWIG_fail;
37811 }
37812 Py_INCREF(Py_None); resultobj = Py_None;
37813 return resultobj;
37814 fail:
37815 return NULL;
37816 }
37817
37818
37819 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37820 PyObject *resultobj;
37821 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37822 wxBitmap *result;
37823 PyObject * obj0 = 0 ;
37824 char *kwnames[] = {
37825 (char *) "self", NULL
37826 };
37827
37828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37830 if (SWIG_arg_fail(1)) SWIG_fail;
37831 {
37832 PyThreadState* __tstate = wxPyBeginAllowThreads();
37833 {
37834 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37835 result = (wxBitmap *) &_result_ref;
37836 }
37837
37838 wxPyEndAllowThreads(__tstate);
37839 if (PyErr_Occurred()) SWIG_fail;
37840 }
37841 {
37842 wxBitmap* resultptr = new wxBitmap(*result);
37843 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37844 }
37845 return resultobj;
37846 fail:
37847 return NULL;
37848 }
37849
37850
37851 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37852 PyObject *resultobj;
37853 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37854 int arg2 ;
37855 PyObject * obj0 = 0 ;
37856 PyObject * obj1 = 0 ;
37857 char *kwnames[] = {
37858 (char *) "self",(char *) "nWidth", NULL
37859 };
37860
37861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37863 if (SWIG_arg_fail(1)) SWIG_fail;
37864 {
37865 arg2 = (int)(SWIG_As_int(obj1));
37866 if (SWIG_arg_fail(2)) SWIG_fail;
37867 }
37868 {
37869 PyThreadState* __tstate = wxPyBeginAllowThreads();
37870 wxMenuItem_SetMarginWidth(arg1,arg2);
37871
37872 wxPyEndAllowThreads(__tstate);
37873 if (PyErr_Occurred()) SWIG_fail;
37874 }
37875 Py_INCREF(Py_None); resultobj = Py_None;
37876 return resultobj;
37877 fail:
37878 return NULL;
37879 }
37880
37881
37882 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37883 PyObject *resultobj;
37884 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37885 int result;
37886 PyObject * obj0 = 0 ;
37887 char *kwnames[] = {
37888 (char *) "self", NULL
37889 };
37890
37891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37893 if (SWIG_arg_fail(1)) SWIG_fail;
37894 {
37895 PyThreadState* __tstate = wxPyBeginAllowThreads();
37896 result = (int)wxMenuItem_GetMarginWidth(arg1);
37897
37898 wxPyEndAllowThreads(__tstate);
37899 if (PyErr_Occurred()) SWIG_fail;
37900 }
37901 {
37902 resultobj = SWIG_From_int((int)(result));
37903 }
37904 return resultobj;
37905 fail:
37906 return NULL;
37907 }
37908
37909
37910 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37911 PyObject *resultobj;
37912 int result;
37913 char *kwnames[] = {
37914 NULL
37915 };
37916
37917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37918 {
37919 PyThreadState* __tstate = wxPyBeginAllowThreads();
37920 result = (int)MenuItem_GetDefaultMarginWidth();
37921
37922 wxPyEndAllowThreads(__tstate);
37923 if (PyErr_Occurred()) SWIG_fail;
37924 }
37925 {
37926 resultobj = SWIG_From_int((int)(result));
37927 }
37928 return resultobj;
37929 fail:
37930 return NULL;
37931 }
37932
37933
37934 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37935 PyObject *resultobj;
37936 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37937 bool result;
37938 PyObject * obj0 = 0 ;
37939 char *kwnames[] = {
37940 (char *) "self", NULL
37941 };
37942
37943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37945 if (SWIG_arg_fail(1)) SWIG_fail;
37946 {
37947 PyThreadState* __tstate = wxPyBeginAllowThreads();
37948 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37949
37950 wxPyEndAllowThreads(__tstate);
37951 if (PyErr_Occurred()) SWIG_fail;
37952 }
37953 {
37954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37955 }
37956 return resultobj;
37957 fail:
37958 return NULL;
37959 }
37960
37961
37962 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37963 PyObject *resultobj;
37964 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37965 bool arg2 = (bool) true ;
37966 PyObject * obj0 = 0 ;
37967 PyObject * obj1 = 0 ;
37968 char *kwnames[] = {
37969 (char *) "self",(char *) "ownerDrawn", NULL
37970 };
37971
37972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37974 if (SWIG_arg_fail(1)) SWIG_fail;
37975 if (obj1) {
37976 {
37977 arg2 = (bool)(SWIG_As_bool(obj1));
37978 if (SWIG_arg_fail(2)) SWIG_fail;
37979 }
37980 }
37981 {
37982 PyThreadState* __tstate = wxPyBeginAllowThreads();
37983 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37984
37985 wxPyEndAllowThreads(__tstate);
37986 if (PyErr_Occurred()) SWIG_fail;
37987 }
37988 Py_INCREF(Py_None); resultobj = Py_None;
37989 return resultobj;
37990 fail:
37991 return NULL;
37992 }
37993
37994
37995 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37996 PyObject *resultobj;
37997 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37998 PyObject * obj0 = 0 ;
37999 char *kwnames[] = {
38000 (char *) "self", NULL
38001 };
38002
38003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
38004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38005 if (SWIG_arg_fail(1)) SWIG_fail;
38006 {
38007 PyThreadState* __tstate = wxPyBeginAllowThreads();
38008 wxMenuItem_ResetOwnerDrawn(arg1);
38009
38010 wxPyEndAllowThreads(__tstate);
38011 if (PyErr_Occurred()) SWIG_fail;
38012 }
38013 Py_INCREF(Py_None); resultobj = Py_None;
38014 return resultobj;
38015 fail:
38016 return NULL;
38017 }
38018
38019
38020 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
38021 PyObject *obj;
38022 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38023 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
38024 Py_INCREF(obj);
38025 return Py_BuildValue((char *)"");
38026 }
38027 static int _wrap_ControlNameStr_set(PyObject *) {
38028 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
38029 return 1;
38030 }
38031
38032
38033 static PyObject *_wrap_ControlNameStr_get(void) {
38034 PyObject *pyobj;
38035
38036 {
38037 #if wxUSE_UNICODE
38038 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38039 #else
38040 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38041 #endif
38042 }
38043 return pyobj;
38044 }
38045
38046
38047 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
38048 PyObject *resultobj;
38049 wxWindow *arg1 = (wxWindow *) 0 ;
38050 int arg2 = (int) -1 ;
38051 wxPoint const &arg3_defvalue = wxDefaultPosition ;
38052 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
38053 wxSize const &arg4_defvalue = wxDefaultSize ;
38054 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
38055 long arg5 = (long) 0 ;
38056 wxValidator const &arg6_defvalue = wxDefaultValidator ;
38057 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
38058 wxString const &arg7_defvalue = wxPyControlNameStr ;
38059 wxString *arg7 = (wxString *) &arg7_defvalue ;
38060 wxControl *result;
38061 wxPoint temp3 ;
38062 wxSize temp4 ;
38063 bool temp7 = false ;
38064 PyObject * obj0 = 0 ;
38065 PyObject * obj1 = 0 ;
38066 PyObject * obj2 = 0 ;
38067 PyObject * obj3 = 0 ;
38068 PyObject * obj4 = 0 ;
38069 PyObject * obj5 = 0 ;
38070 PyObject * obj6 = 0 ;
38071 char *kwnames[] = {
38072 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38073 };
38074
38075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38077 if (SWIG_arg_fail(1)) SWIG_fail;
38078 if (obj1) {
38079 {
38080 arg2 = (int)(SWIG_As_int(obj1));
38081 if (SWIG_arg_fail(2)) SWIG_fail;
38082 }
38083 }
38084 if (obj2) {
38085 {
38086 arg3 = &temp3;
38087 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38088 }
38089 }
38090 if (obj3) {
38091 {
38092 arg4 = &temp4;
38093 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38094 }
38095 }
38096 if (obj4) {
38097 {
38098 arg5 = (long)(SWIG_As_long(obj4));
38099 if (SWIG_arg_fail(5)) SWIG_fail;
38100 }
38101 }
38102 if (obj5) {
38103 {
38104 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38105 if (SWIG_arg_fail(6)) SWIG_fail;
38106 if (arg6 == NULL) {
38107 SWIG_null_ref("wxValidator");
38108 }
38109 if (SWIG_arg_fail(6)) SWIG_fail;
38110 }
38111 }
38112 if (obj6) {
38113 {
38114 arg7 = wxString_in_helper(obj6);
38115 if (arg7 == NULL) SWIG_fail;
38116 temp7 = true;
38117 }
38118 }
38119 {
38120 if (!wxPyCheckForApp()) SWIG_fail;
38121 PyThreadState* __tstate = wxPyBeginAllowThreads();
38122 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38123
38124 wxPyEndAllowThreads(__tstate);
38125 if (PyErr_Occurred()) SWIG_fail;
38126 }
38127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38128 {
38129 if (temp7)
38130 delete arg7;
38131 }
38132 return resultobj;
38133 fail:
38134 {
38135 if (temp7)
38136 delete arg7;
38137 }
38138 return NULL;
38139 }
38140
38141
38142 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38143 PyObject *resultobj;
38144 wxControl *result;
38145 char *kwnames[] = {
38146 NULL
38147 };
38148
38149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38150 {
38151 if (!wxPyCheckForApp()) SWIG_fail;
38152 PyThreadState* __tstate = wxPyBeginAllowThreads();
38153 result = (wxControl *)new wxControl();
38154
38155 wxPyEndAllowThreads(__tstate);
38156 if (PyErr_Occurred()) SWIG_fail;
38157 }
38158 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38159 return resultobj;
38160 fail:
38161 return NULL;
38162 }
38163
38164
38165 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38166 PyObject *resultobj;
38167 wxControl *arg1 = (wxControl *) 0 ;
38168 wxWindow *arg2 = (wxWindow *) 0 ;
38169 int arg3 = (int) -1 ;
38170 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38171 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38172 wxSize const &arg5_defvalue = wxDefaultSize ;
38173 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38174 long arg6 = (long) 0 ;
38175 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38176 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38177 wxString const &arg8_defvalue = wxPyControlNameStr ;
38178 wxString *arg8 = (wxString *) &arg8_defvalue ;
38179 bool result;
38180 wxPoint temp4 ;
38181 wxSize temp5 ;
38182 bool temp8 = false ;
38183 PyObject * obj0 = 0 ;
38184 PyObject * obj1 = 0 ;
38185 PyObject * obj2 = 0 ;
38186 PyObject * obj3 = 0 ;
38187 PyObject * obj4 = 0 ;
38188 PyObject * obj5 = 0 ;
38189 PyObject * obj6 = 0 ;
38190 PyObject * obj7 = 0 ;
38191 char *kwnames[] = {
38192 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38193 };
38194
38195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38197 if (SWIG_arg_fail(1)) SWIG_fail;
38198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38199 if (SWIG_arg_fail(2)) SWIG_fail;
38200 if (obj2) {
38201 {
38202 arg3 = (int)(SWIG_As_int(obj2));
38203 if (SWIG_arg_fail(3)) SWIG_fail;
38204 }
38205 }
38206 if (obj3) {
38207 {
38208 arg4 = &temp4;
38209 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38210 }
38211 }
38212 if (obj4) {
38213 {
38214 arg5 = &temp5;
38215 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38216 }
38217 }
38218 if (obj5) {
38219 {
38220 arg6 = (long)(SWIG_As_long(obj5));
38221 if (SWIG_arg_fail(6)) SWIG_fail;
38222 }
38223 }
38224 if (obj6) {
38225 {
38226 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38227 if (SWIG_arg_fail(7)) SWIG_fail;
38228 if (arg7 == NULL) {
38229 SWIG_null_ref("wxValidator");
38230 }
38231 if (SWIG_arg_fail(7)) SWIG_fail;
38232 }
38233 }
38234 if (obj7) {
38235 {
38236 arg8 = wxString_in_helper(obj7);
38237 if (arg8 == NULL) SWIG_fail;
38238 temp8 = true;
38239 }
38240 }
38241 {
38242 PyThreadState* __tstate = wxPyBeginAllowThreads();
38243 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38244
38245 wxPyEndAllowThreads(__tstate);
38246 if (PyErr_Occurred()) SWIG_fail;
38247 }
38248 {
38249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38250 }
38251 {
38252 if (temp8)
38253 delete arg8;
38254 }
38255 return resultobj;
38256 fail:
38257 {
38258 if (temp8)
38259 delete arg8;
38260 }
38261 return NULL;
38262 }
38263
38264
38265 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38266 PyObject *resultobj;
38267 wxControl *arg1 = (wxControl *) 0 ;
38268 wxCommandEvent *arg2 = 0 ;
38269 PyObject * obj0 = 0 ;
38270 PyObject * obj1 = 0 ;
38271 char *kwnames[] = {
38272 (char *) "self",(char *) "event", NULL
38273 };
38274
38275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38277 if (SWIG_arg_fail(1)) SWIG_fail;
38278 {
38279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38280 if (SWIG_arg_fail(2)) SWIG_fail;
38281 if (arg2 == NULL) {
38282 SWIG_null_ref("wxCommandEvent");
38283 }
38284 if (SWIG_arg_fail(2)) SWIG_fail;
38285 }
38286 {
38287 PyThreadState* __tstate = wxPyBeginAllowThreads();
38288 (arg1)->Command(*arg2);
38289
38290 wxPyEndAllowThreads(__tstate);
38291 if (PyErr_Occurred()) SWIG_fail;
38292 }
38293 Py_INCREF(Py_None); resultobj = Py_None;
38294 return resultobj;
38295 fail:
38296 return NULL;
38297 }
38298
38299
38300 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38301 PyObject *resultobj;
38302 wxControl *arg1 = (wxControl *) 0 ;
38303 wxString result;
38304 PyObject * obj0 = 0 ;
38305 char *kwnames[] = {
38306 (char *) "self", NULL
38307 };
38308
38309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38311 if (SWIG_arg_fail(1)) SWIG_fail;
38312 {
38313 PyThreadState* __tstate = wxPyBeginAllowThreads();
38314 result = (arg1)->GetLabel();
38315
38316 wxPyEndAllowThreads(__tstate);
38317 if (PyErr_Occurred()) SWIG_fail;
38318 }
38319 {
38320 #if wxUSE_UNICODE
38321 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38322 #else
38323 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38324 #endif
38325 }
38326 return resultobj;
38327 fail:
38328 return NULL;
38329 }
38330
38331
38332 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38333 PyObject *resultobj;
38334 wxControl *arg1 = (wxControl *) 0 ;
38335 wxString *arg2 = 0 ;
38336 bool temp2 = false ;
38337 PyObject * obj0 = 0 ;
38338 PyObject * obj1 = 0 ;
38339 char *kwnames[] = {
38340 (char *) "self",(char *) "label", NULL
38341 };
38342
38343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38345 if (SWIG_arg_fail(1)) SWIG_fail;
38346 {
38347 arg2 = wxString_in_helper(obj1);
38348 if (arg2 == NULL) SWIG_fail;
38349 temp2 = true;
38350 }
38351 {
38352 PyThreadState* __tstate = wxPyBeginAllowThreads();
38353 (arg1)->SetLabel((wxString const &)*arg2);
38354
38355 wxPyEndAllowThreads(__tstate);
38356 if (PyErr_Occurred()) SWIG_fail;
38357 }
38358 Py_INCREF(Py_None); resultobj = Py_None;
38359 {
38360 if (temp2)
38361 delete arg2;
38362 }
38363 return resultobj;
38364 fail:
38365 {
38366 if (temp2)
38367 delete arg2;
38368 }
38369 return NULL;
38370 }
38371
38372
38373 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38374 PyObject *resultobj;
38375 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38376 wxVisualAttributes result;
38377 PyObject * obj0 = 0 ;
38378 char *kwnames[] = {
38379 (char *) "variant", NULL
38380 };
38381
38382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38383 if (obj0) {
38384 {
38385 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
38386 if (SWIG_arg_fail(1)) SWIG_fail;
38387 }
38388 }
38389 {
38390 if (!wxPyCheckForApp()) SWIG_fail;
38391 PyThreadState* __tstate = wxPyBeginAllowThreads();
38392 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
38393
38394 wxPyEndAllowThreads(__tstate);
38395 if (PyErr_Occurred()) SWIG_fail;
38396 }
38397 {
38398 wxVisualAttributes * resultptr;
38399 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
38400 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38401 }
38402 return resultobj;
38403 fail:
38404 return NULL;
38405 }
38406
38407
38408 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38409 PyObject *obj;
38410 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38411 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38412 Py_INCREF(obj);
38413 return Py_BuildValue((char *)"");
38414 }
38415 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38416 PyObject *resultobj;
38417 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38418 wxString *arg2 = 0 ;
38419 PyObject *arg3 = (PyObject *) NULL ;
38420 int result;
38421 bool temp2 = false ;
38422 PyObject * obj0 = 0 ;
38423 PyObject * obj1 = 0 ;
38424 PyObject * obj2 = 0 ;
38425 char *kwnames[] = {
38426 (char *) "self",(char *) "item",(char *) "clientData", NULL
38427 };
38428
38429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38431 if (SWIG_arg_fail(1)) SWIG_fail;
38432 {
38433 arg2 = wxString_in_helper(obj1);
38434 if (arg2 == NULL) SWIG_fail;
38435 temp2 = true;
38436 }
38437 if (obj2) {
38438 arg3 = obj2;
38439 }
38440 {
38441 PyThreadState* __tstate = wxPyBeginAllowThreads();
38442 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38443
38444 wxPyEndAllowThreads(__tstate);
38445 if (PyErr_Occurred()) SWIG_fail;
38446 }
38447 {
38448 resultobj = SWIG_From_int((int)(result));
38449 }
38450 {
38451 if (temp2)
38452 delete arg2;
38453 }
38454 return resultobj;
38455 fail:
38456 {
38457 if (temp2)
38458 delete arg2;
38459 }
38460 return NULL;
38461 }
38462
38463
38464 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38465 PyObject *resultobj;
38466 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38467 wxArrayString *arg2 = 0 ;
38468 bool temp2 = false ;
38469 PyObject * obj0 = 0 ;
38470 PyObject * obj1 = 0 ;
38471 char *kwnames[] = {
38472 (char *) "self",(char *) "strings", NULL
38473 };
38474
38475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38477 if (SWIG_arg_fail(1)) SWIG_fail;
38478 {
38479 if (! PySequence_Check(obj1)) {
38480 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38481 SWIG_fail;
38482 }
38483 arg2 = new wxArrayString;
38484 temp2 = true;
38485 int i, len=PySequence_Length(obj1);
38486 for (i=0; i<len; i++) {
38487 PyObject* item = PySequence_GetItem(obj1, i);
38488 wxString* s = wxString_in_helper(item);
38489 if (PyErr_Occurred()) SWIG_fail;
38490 arg2->Add(*s);
38491 delete s;
38492 Py_DECREF(item);
38493 }
38494 }
38495 {
38496 PyThreadState* __tstate = wxPyBeginAllowThreads();
38497 (arg1)->Append((wxArrayString const &)*arg2);
38498
38499 wxPyEndAllowThreads(__tstate);
38500 if (PyErr_Occurred()) SWIG_fail;
38501 }
38502 Py_INCREF(Py_None); resultobj = Py_None;
38503 {
38504 if (temp2) delete arg2;
38505 }
38506 return resultobj;
38507 fail:
38508 {
38509 if (temp2) delete arg2;
38510 }
38511 return NULL;
38512 }
38513
38514
38515 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38516 PyObject *resultobj;
38517 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38518 wxString *arg2 = 0 ;
38519 int arg3 ;
38520 PyObject *arg4 = (PyObject *) NULL ;
38521 int result;
38522 bool temp2 = false ;
38523 PyObject * obj0 = 0 ;
38524 PyObject * obj1 = 0 ;
38525 PyObject * obj2 = 0 ;
38526 PyObject * obj3 = 0 ;
38527 char *kwnames[] = {
38528 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38529 };
38530
38531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38533 if (SWIG_arg_fail(1)) SWIG_fail;
38534 {
38535 arg2 = wxString_in_helper(obj1);
38536 if (arg2 == NULL) SWIG_fail;
38537 temp2 = true;
38538 }
38539 {
38540 arg3 = (int)(SWIG_As_int(obj2));
38541 if (SWIG_arg_fail(3)) SWIG_fail;
38542 }
38543 if (obj3) {
38544 arg4 = obj3;
38545 }
38546 {
38547 PyThreadState* __tstate = wxPyBeginAllowThreads();
38548 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38549
38550 wxPyEndAllowThreads(__tstate);
38551 if (PyErr_Occurred()) SWIG_fail;
38552 }
38553 {
38554 resultobj = SWIG_From_int((int)(result));
38555 }
38556 {
38557 if (temp2)
38558 delete arg2;
38559 }
38560 return resultobj;
38561 fail:
38562 {
38563 if (temp2)
38564 delete arg2;
38565 }
38566 return NULL;
38567 }
38568
38569
38570 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38571 PyObject *resultobj;
38572 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38573 PyObject * obj0 = 0 ;
38574 char *kwnames[] = {
38575 (char *) "self", NULL
38576 };
38577
38578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38580 if (SWIG_arg_fail(1)) SWIG_fail;
38581 {
38582 PyThreadState* __tstate = wxPyBeginAllowThreads();
38583 (arg1)->Clear();
38584
38585 wxPyEndAllowThreads(__tstate);
38586 if (PyErr_Occurred()) SWIG_fail;
38587 }
38588 Py_INCREF(Py_None); resultobj = Py_None;
38589 return resultobj;
38590 fail:
38591 return NULL;
38592 }
38593
38594
38595 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38596 PyObject *resultobj;
38597 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38598 int arg2 ;
38599 PyObject * obj0 = 0 ;
38600 PyObject * obj1 = 0 ;
38601 char *kwnames[] = {
38602 (char *) "self",(char *) "n", NULL
38603 };
38604
38605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38607 if (SWIG_arg_fail(1)) SWIG_fail;
38608 {
38609 arg2 = (int)(SWIG_As_int(obj1));
38610 if (SWIG_arg_fail(2)) SWIG_fail;
38611 }
38612 {
38613 PyThreadState* __tstate = wxPyBeginAllowThreads();
38614 (arg1)->Delete(arg2);
38615
38616 wxPyEndAllowThreads(__tstate);
38617 if (PyErr_Occurred()) SWIG_fail;
38618 }
38619 Py_INCREF(Py_None); resultobj = Py_None;
38620 return resultobj;
38621 fail:
38622 return NULL;
38623 }
38624
38625
38626 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38627 PyObject *resultobj;
38628 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38629 int arg2 ;
38630 PyObject *result;
38631 PyObject * obj0 = 0 ;
38632 PyObject * obj1 = 0 ;
38633 char *kwnames[] = {
38634 (char *) "self",(char *) "n", NULL
38635 };
38636
38637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38639 if (SWIG_arg_fail(1)) SWIG_fail;
38640 {
38641 arg2 = (int)(SWIG_As_int(obj1));
38642 if (SWIG_arg_fail(2)) SWIG_fail;
38643 }
38644 {
38645 PyThreadState* __tstate = wxPyBeginAllowThreads();
38646 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38647
38648 wxPyEndAllowThreads(__tstate);
38649 if (PyErr_Occurred()) SWIG_fail;
38650 }
38651 resultobj = result;
38652 return resultobj;
38653 fail:
38654 return NULL;
38655 }
38656
38657
38658 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38659 PyObject *resultobj;
38660 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38661 int arg2 ;
38662 PyObject *arg3 = (PyObject *) 0 ;
38663 PyObject * obj0 = 0 ;
38664 PyObject * obj1 = 0 ;
38665 PyObject * obj2 = 0 ;
38666 char *kwnames[] = {
38667 (char *) "self",(char *) "n",(char *) "clientData", NULL
38668 };
38669
38670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38672 if (SWIG_arg_fail(1)) SWIG_fail;
38673 {
38674 arg2 = (int)(SWIG_As_int(obj1));
38675 if (SWIG_arg_fail(2)) SWIG_fail;
38676 }
38677 arg3 = obj2;
38678 {
38679 PyThreadState* __tstate = wxPyBeginAllowThreads();
38680 wxItemContainer_SetClientData(arg1,arg2,arg3);
38681
38682 wxPyEndAllowThreads(__tstate);
38683 if (PyErr_Occurred()) SWIG_fail;
38684 }
38685 Py_INCREF(Py_None); resultobj = Py_None;
38686 return resultobj;
38687 fail:
38688 return NULL;
38689 }
38690
38691
38692 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38693 PyObject *resultobj;
38694 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38695 int result;
38696 PyObject * obj0 = 0 ;
38697 char *kwnames[] = {
38698 (char *) "self", NULL
38699 };
38700
38701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38703 if (SWIG_arg_fail(1)) SWIG_fail;
38704 {
38705 PyThreadState* __tstate = wxPyBeginAllowThreads();
38706 result = (int)((wxItemContainer const *)arg1)->GetCount();
38707
38708 wxPyEndAllowThreads(__tstate);
38709 if (PyErr_Occurred()) SWIG_fail;
38710 }
38711 {
38712 resultobj = SWIG_From_int((int)(result));
38713 }
38714 return resultobj;
38715 fail:
38716 return NULL;
38717 }
38718
38719
38720 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38721 PyObject *resultobj;
38722 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38723 bool result;
38724 PyObject * obj0 = 0 ;
38725 char *kwnames[] = {
38726 (char *) "self", NULL
38727 };
38728
38729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38731 if (SWIG_arg_fail(1)) SWIG_fail;
38732 {
38733 PyThreadState* __tstate = wxPyBeginAllowThreads();
38734 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38735
38736 wxPyEndAllowThreads(__tstate);
38737 if (PyErr_Occurred()) SWIG_fail;
38738 }
38739 {
38740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38741 }
38742 return resultobj;
38743 fail:
38744 return NULL;
38745 }
38746
38747
38748 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38749 PyObject *resultobj;
38750 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38751 int arg2 ;
38752 wxString result;
38753 PyObject * obj0 = 0 ;
38754 PyObject * obj1 = 0 ;
38755 char *kwnames[] = {
38756 (char *) "self",(char *) "n", NULL
38757 };
38758
38759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38761 if (SWIG_arg_fail(1)) SWIG_fail;
38762 {
38763 arg2 = (int)(SWIG_As_int(obj1));
38764 if (SWIG_arg_fail(2)) SWIG_fail;
38765 }
38766 {
38767 PyThreadState* __tstate = wxPyBeginAllowThreads();
38768 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38769
38770 wxPyEndAllowThreads(__tstate);
38771 if (PyErr_Occurred()) SWIG_fail;
38772 }
38773 {
38774 #if wxUSE_UNICODE
38775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38776 #else
38777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38778 #endif
38779 }
38780 return resultobj;
38781 fail:
38782 return NULL;
38783 }
38784
38785
38786 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38787 PyObject *resultobj;
38788 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38789 wxArrayString result;
38790 PyObject * obj0 = 0 ;
38791 char *kwnames[] = {
38792 (char *) "self", NULL
38793 };
38794
38795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38797 if (SWIG_arg_fail(1)) SWIG_fail;
38798 {
38799 PyThreadState* __tstate = wxPyBeginAllowThreads();
38800 result = ((wxItemContainer const *)arg1)->GetStrings();
38801
38802 wxPyEndAllowThreads(__tstate);
38803 if (PyErr_Occurred()) SWIG_fail;
38804 }
38805 {
38806 resultobj = wxArrayString2PyList_helper(result);
38807 }
38808 return resultobj;
38809 fail:
38810 return NULL;
38811 }
38812
38813
38814 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38815 PyObject *resultobj;
38816 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38817 int arg2 ;
38818 wxString *arg3 = 0 ;
38819 bool temp3 = false ;
38820 PyObject * obj0 = 0 ;
38821 PyObject * obj1 = 0 ;
38822 PyObject * obj2 = 0 ;
38823 char *kwnames[] = {
38824 (char *) "self",(char *) "n",(char *) "s", NULL
38825 };
38826
38827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38829 if (SWIG_arg_fail(1)) SWIG_fail;
38830 {
38831 arg2 = (int)(SWIG_As_int(obj1));
38832 if (SWIG_arg_fail(2)) SWIG_fail;
38833 }
38834 {
38835 arg3 = wxString_in_helper(obj2);
38836 if (arg3 == NULL) SWIG_fail;
38837 temp3 = true;
38838 }
38839 {
38840 PyThreadState* __tstate = wxPyBeginAllowThreads();
38841 (arg1)->SetString(arg2,(wxString const &)*arg3);
38842
38843 wxPyEndAllowThreads(__tstate);
38844 if (PyErr_Occurred()) SWIG_fail;
38845 }
38846 Py_INCREF(Py_None); resultobj = Py_None;
38847 {
38848 if (temp3)
38849 delete arg3;
38850 }
38851 return resultobj;
38852 fail:
38853 {
38854 if (temp3)
38855 delete arg3;
38856 }
38857 return NULL;
38858 }
38859
38860
38861 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38862 PyObject *resultobj;
38863 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38864 wxString *arg2 = 0 ;
38865 int result;
38866 bool temp2 = false ;
38867 PyObject * obj0 = 0 ;
38868 PyObject * obj1 = 0 ;
38869 char *kwnames[] = {
38870 (char *) "self",(char *) "s", NULL
38871 };
38872
38873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38875 if (SWIG_arg_fail(1)) SWIG_fail;
38876 {
38877 arg2 = wxString_in_helper(obj1);
38878 if (arg2 == NULL) SWIG_fail;
38879 temp2 = true;
38880 }
38881 {
38882 PyThreadState* __tstate = wxPyBeginAllowThreads();
38883 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38884
38885 wxPyEndAllowThreads(__tstate);
38886 if (PyErr_Occurred()) SWIG_fail;
38887 }
38888 {
38889 resultobj = SWIG_From_int((int)(result));
38890 }
38891 {
38892 if (temp2)
38893 delete arg2;
38894 }
38895 return resultobj;
38896 fail:
38897 {
38898 if (temp2)
38899 delete arg2;
38900 }
38901 return NULL;
38902 }
38903
38904
38905 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38906 PyObject *resultobj;
38907 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38908 int arg2 ;
38909 PyObject * obj0 = 0 ;
38910 PyObject * obj1 = 0 ;
38911 char *kwnames[] = {
38912 (char *) "self",(char *) "n", NULL
38913 };
38914
38915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38917 if (SWIG_arg_fail(1)) SWIG_fail;
38918 {
38919 arg2 = (int)(SWIG_As_int(obj1));
38920 if (SWIG_arg_fail(2)) SWIG_fail;
38921 }
38922 {
38923 PyThreadState* __tstate = wxPyBeginAllowThreads();
38924 (arg1)->SetSelection(arg2);
38925
38926 wxPyEndAllowThreads(__tstate);
38927 if (PyErr_Occurred()) SWIG_fail;
38928 }
38929 Py_INCREF(Py_None); resultobj = Py_None;
38930 return resultobj;
38931 fail:
38932 return NULL;
38933 }
38934
38935
38936 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38937 PyObject *resultobj;
38938 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38939 int result;
38940 PyObject * obj0 = 0 ;
38941 char *kwnames[] = {
38942 (char *) "self", NULL
38943 };
38944
38945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38947 if (SWIG_arg_fail(1)) SWIG_fail;
38948 {
38949 PyThreadState* __tstate = wxPyBeginAllowThreads();
38950 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38951
38952 wxPyEndAllowThreads(__tstate);
38953 if (PyErr_Occurred()) SWIG_fail;
38954 }
38955 {
38956 resultobj = SWIG_From_int((int)(result));
38957 }
38958 return resultobj;
38959 fail:
38960 return NULL;
38961 }
38962
38963
38964 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38965 PyObject *resultobj;
38966 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38967 wxString *arg2 = 0 ;
38968 bool result;
38969 bool temp2 = false ;
38970 PyObject * obj0 = 0 ;
38971 PyObject * obj1 = 0 ;
38972 char *kwnames[] = {
38973 (char *) "self",(char *) "s", NULL
38974 };
38975
38976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38978 if (SWIG_arg_fail(1)) SWIG_fail;
38979 {
38980 arg2 = wxString_in_helper(obj1);
38981 if (arg2 == NULL) SWIG_fail;
38982 temp2 = true;
38983 }
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38987
38988 wxPyEndAllowThreads(__tstate);
38989 if (PyErr_Occurred()) SWIG_fail;
38990 }
38991 {
38992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38993 }
38994 {
38995 if (temp2)
38996 delete arg2;
38997 }
38998 return resultobj;
38999 fail:
39000 {
39001 if (temp2)
39002 delete arg2;
39003 }
39004 return NULL;
39005 }
39006
39007
39008 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39009 PyObject *resultobj;
39010 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39011 wxString result;
39012 PyObject * obj0 = 0 ;
39013 char *kwnames[] = {
39014 (char *) "self", NULL
39015 };
39016
39017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
39018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39019 if (SWIG_arg_fail(1)) SWIG_fail;
39020 {
39021 PyThreadState* __tstate = wxPyBeginAllowThreads();
39022 result = ((wxItemContainer const *)arg1)->GetStringSelection();
39023
39024 wxPyEndAllowThreads(__tstate);
39025 if (PyErr_Occurred()) SWIG_fail;
39026 }
39027 {
39028 #if wxUSE_UNICODE
39029 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39030 #else
39031 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39032 #endif
39033 }
39034 return resultobj;
39035 fail:
39036 return NULL;
39037 }
39038
39039
39040 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
39041 PyObject *resultobj;
39042 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39043 int arg2 ;
39044 PyObject * obj0 = 0 ;
39045 PyObject * obj1 = 0 ;
39046 char *kwnames[] = {
39047 (char *) "self",(char *) "n", NULL
39048 };
39049
39050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
39051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39052 if (SWIG_arg_fail(1)) SWIG_fail;
39053 {
39054 arg2 = (int)(SWIG_As_int(obj1));
39055 if (SWIG_arg_fail(2)) SWIG_fail;
39056 }
39057 {
39058 PyThreadState* __tstate = wxPyBeginAllowThreads();
39059 (arg1)->Select(arg2);
39060
39061 wxPyEndAllowThreads(__tstate);
39062 if (PyErr_Occurred()) SWIG_fail;
39063 }
39064 Py_INCREF(Py_None); resultobj = Py_None;
39065 return resultobj;
39066 fail:
39067 return NULL;
39068 }
39069
39070
39071 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39072 PyObject *obj;
39073 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39074 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39075 Py_INCREF(obj);
39076 return Py_BuildValue((char *)"");
39077 }
39078 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39079 PyObject *obj;
39080 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39081 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39082 Py_INCREF(obj);
39083 return Py_BuildValue((char *)"");
39084 }
39085 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39086 PyObject *resultobj;
39087 wxSizerItem *result;
39088 char *kwnames[] = {
39089 NULL
39090 };
39091
39092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39093 {
39094 PyThreadState* __tstate = wxPyBeginAllowThreads();
39095 result = (wxSizerItem *)new wxSizerItem();
39096
39097 wxPyEndAllowThreads(__tstate);
39098 if (PyErr_Occurred()) SWIG_fail;
39099 }
39100 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39101 return resultobj;
39102 fail:
39103 return NULL;
39104 }
39105
39106
39107 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39108 PyObject *resultobj;
39109 wxWindow *arg1 = (wxWindow *) 0 ;
39110 int arg2 ;
39111 int arg3 ;
39112 int arg4 ;
39113 PyObject *arg5 = (PyObject *) NULL ;
39114 wxSizerItem *result;
39115 PyObject * obj0 = 0 ;
39116 PyObject * obj1 = 0 ;
39117 PyObject * obj2 = 0 ;
39118 PyObject * obj3 = 0 ;
39119 PyObject * obj4 = 0 ;
39120 char *kwnames[] = {
39121 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39122 };
39123
39124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39126 if (SWIG_arg_fail(1)) SWIG_fail;
39127 {
39128 arg2 = (int)(SWIG_As_int(obj1));
39129 if (SWIG_arg_fail(2)) SWIG_fail;
39130 }
39131 {
39132 arg3 = (int)(SWIG_As_int(obj2));
39133 if (SWIG_arg_fail(3)) SWIG_fail;
39134 }
39135 {
39136 arg4 = (int)(SWIG_As_int(obj3));
39137 if (SWIG_arg_fail(4)) SWIG_fail;
39138 }
39139 if (obj4) {
39140 arg5 = obj4;
39141 }
39142 {
39143 PyThreadState* __tstate = wxPyBeginAllowThreads();
39144 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39145
39146 wxPyEndAllowThreads(__tstate);
39147 if (PyErr_Occurred()) SWIG_fail;
39148 }
39149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39150 return resultobj;
39151 fail:
39152 return NULL;
39153 }
39154
39155
39156 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39157 PyObject *resultobj;
39158 int arg1 ;
39159 int arg2 ;
39160 int arg3 ;
39161 int arg4 ;
39162 int arg5 ;
39163 PyObject *arg6 = (PyObject *) NULL ;
39164 wxSizerItem *result;
39165 PyObject * obj0 = 0 ;
39166 PyObject * obj1 = 0 ;
39167 PyObject * obj2 = 0 ;
39168 PyObject * obj3 = 0 ;
39169 PyObject * obj4 = 0 ;
39170 PyObject * obj5 = 0 ;
39171 char *kwnames[] = {
39172 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39173 };
39174
39175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39176 {
39177 arg1 = (int)(SWIG_As_int(obj0));
39178 if (SWIG_arg_fail(1)) SWIG_fail;
39179 }
39180 {
39181 arg2 = (int)(SWIG_As_int(obj1));
39182 if (SWIG_arg_fail(2)) SWIG_fail;
39183 }
39184 {
39185 arg3 = (int)(SWIG_As_int(obj2));
39186 if (SWIG_arg_fail(3)) SWIG_fail;
39187 }
39188 {
39189 arg4 = (int)(SWIG_As_int(obj3));
39190 if (SWIG_arg_fail(4)) SWIG_fail;
39191 }
39192 {
39193 arg5 = (int)(SWIG_As_int(obj4));
39194 if (SWIG_arg_fail(5)) SWIG_fail;
39195 }
39196 if (obj5) {
39197 arg6 = obj5;
39198 }
39199 {
39200 PyThreadState* __tstate = wxPyBeginAllowThreads();
39201 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39202
39203 wxPyEndAllowThreads(__tstate);
39204 if (PyErr_Occurred()) SWIG_fail;
39205 }
39206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39207 return resultobj;
39208 fail:
39209 return NULL;
39210 }
39211
39212
39213 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39214 PyObject *resultobj;
39215 wxSizer *arg1 = (wxSizer *) 0 ;
39216 int arg2 ;
39217 int arg3 ;
39218 int arg4 ;
39219 PyObject *arg5 = (PyObject *) NULL ;
39220 wxSizerItem *result;
39221 PyObject * obj0 = 0 ;
39222 PyObject * obj1 = 0 ;
39223 PyObject * obj2 = 0 ;
39224 PyObject * obj3 = 0 ;
39225 PyObject * obj4 = 0 ;
39226 char *kwnames[] = {
39227 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39228 };
39229
39230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39232 if (SWIG_arg_fail(1)) SWIG_fail;
39233 {
39234 arg2 = (int)(SWIG_As_int(obj1));
39235 if (SWIG_arg_fail(2)) SWIG_fail;
39236 }
39237 {
39238 arg3 = (int)(SWIG_As_int(obj2));
39239 if (SWIG_arg_fail(3)) SWIG_fail;
39240 }
39241 {
39242 arg4 = (int)(SWIG_As_int(obj3));
39243 if (SWIG_arg_fail(4)) SWIG_fail;
39244 }
39245 if (obj4) {
39246 arg5 = obj4;
39247 }
39248 {
39249 PyThreadState* __tstate = wxPyBeginAllowThreads();
39250 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39251
39252 wxPyEndAllowThreads(__tstate);
39253 if (PyErr_Occurred()) SWIG_fail;
39254 }
39255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39256 return resultobj;
39257 fail:
39258 return NULL;
39259 }
39260
39261
39262 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39263 PyObject *resultobj;
39264 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39265 PyObject * obj0 = 0 ;
39266 char *kwnames[] = {
39267 (char *) "self", NULL
39268 };
39269
39270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39272 if (SWIG_arg_fail(1)) SWIG_fail;
39273 {
39274 PyThreadState* __tstate = wxPyBeginAllowThreads();
39275 (arg1)->DeleteWindows();
39276
39277 wxPyEndAllowThreads(__tstate);
39278 if (PyErr_Occurred()) SWIG_fail;
39279 }
39280 Py_INCREF(Py_None); resultobj = Py_None;
39281 return resultobj;
39282 fail:
39283 return NULL;
39284 }
39285
39286
39287 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39288 PyObject *resultobj;
39289 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39290 PyObject * obj0 = 0 ;
39291 char *kwnames[] = {
39292 (char *) "self", NULL
39293 };
39294
39295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39297 if (SWIG_arg_fail(1)) SWIG_fail;
39298 {
39299 PyThreadState* __tstate = wxPyBeginAllowThreads();
39300 (arg1)->DetachSizer();
39301
39302 wxPyEndAllowThreads(__tstate);
39303 if (PyErr_Occurred()) SWIG_fail;
39304 }
39305 Py_INCREF(Py_None); resultobj = Py_None;
39306 return resultobj;
39307 fail:
39308 return NULL;
39309 }
39310
39311
39312 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39313 PyObject *resultobj;
39314 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39315 wxSize result;
39316 PyObject * obj0 = 0 ;
39317 char *kwnames[] = {
39318 (char *) "self", NULL
39319 };
39320
39321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39323 if (SWIG_arg_fail(1)) SWIG_fail;
39324 {
39325 PyThreadState* __tstate = wxPyBeginAllowThreads();
39326 result = (arg1)->GetSize();
39327
39328 wxPyEndAllowThreads(__tstate);
39329 if (PyErr_Occurred()) SWIG_fail;
39330 }
39331 {
39332 wxSize * resultptr;
39333 resultptr = new wxSize((wxSize &)(result));
39334 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39335 }
39336 return resultobj;
39337 fail:
39338 return NULL;
39339 }
39340
39341
39342 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39343 PyObject *resultobj;
39344 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39345 wxSize result;
39346 PyObject * obj0 = 0 ;
39347 char *kwnames[] = {
39348 (char *) "self", NULL
39349 };
39350
39351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39353 if (SWIG_arg_fail(1)) SWIG_fail;
39354 {
39355 PyThreadState* __tstate = wxPyBeginAllowThreads();
39356 result = (arg1)->CalcMin();
39357
39358 wxPyEndAllowThreads(__tstate);
39359 if (PyErr_Occurred()) SWIG_fail;
39360 }
39361 {
39362 wxSize * resultptr;
39363 resultptr = new wxSize((wxSize &)(result));
39364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39365 }
39366 return resultobj;
39367 fail:
39368 return NULL;
39369 }
39370
39371
39372 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39373 PyObject *resultobj;
39374 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39375 wxPoint arg2 ;
39376 wxSize arg3 ;
39377 PyObject * obj0 = 0 ;
39378 PyObject * obj1 = 0 ;
39379 PyObject * obj2 = 0 ;
39380 char *kwnames[] = {
39381 (char *) "self",(char *) "pos",(char *) "size", NULL
39382 };
39383
39384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39386 if (SWIG_arg_fail(1)) SWIG_fail;
39387 {
39388 wxPoint * argp;
39389 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
39390 if (SWIG_arg_fail(2)) SWIG_fail;
39391 if (argp == NULL) {
39392 SWIG_null_ref("wxPoint");
39393 }
39394 if (SWIG_arg_fail(2)) SWIG_fail;
39395 arg2 = *argp;
39396 }
39397 {
39398 wxSize * argp;
39399 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
39400 if (SWIG_arg_fail(3)) SWIG_fail;
39401 if (argp == NULL) {
39402 SWIG_null_ref("wxSize");
39403 }
39404 if (SWIG_arg_fail(3)) SWIG_fail;
39405 arg3 = *argp;
39406 }
39407 {
39408 PyThreadState* __tstate = wxPyBeginAllowThreads();
39409 (arg1)->SetDimension(arg2,arg3);
39410
39411 wxPyEndAllowThreads(__tstate);
39412 if (PyErr_Occurred()) SWIG_fail;
39413 }
39414 Py_INCREF(Py_None); resultobj = Py_None;
39415 return resultobj;
39416 fail:
39417 return NULL;
39418 }
39419
39420
39421 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39422 PyObject *resultobj;
39423 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39424 wxSize result;
39425 PyObject * obj0 = 0 ;
39426 char *kwnames[] = {
39427 (char *) "self", NULL
39428 };
39429
39430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39432 if (SWIG_arg_fail(1)) SWIG_fail;
39433 {
39434 PyThreadState* __tstate = wxPyBeginAllowThreads();
39435 result = (arg1)->GetMinSize();
39436
39437 wxPyEndAllowThreads(__tstate);
39438 if (PyErr_Occurred()) SWIG_fail;
39439 }
39440 {
39441 wxSize * resultptr;
39442 resultptr = new wxSize((wxSize &)(result));
39443 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39444 }
39445 return resultobj;
39446 fail:
39447 return NULL;
39448 }
39449
39450
39451 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39452 PyObject *resultobj;
39453 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39454 wxSize result;
39455 PyObject * obj0 = 0 ;
39456 char *kwnames[] = {
39457 (char *) "self", NULL
39458 };
39459
39460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39462 if (SWIG_arg_fail(1)) SWIG_fail;
39463 {
39464 PyThreadState* __tstate = wxPyBeginAllowThreads();
39465 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39466
39467 wxPyEndAllowThreads(__tstate);
39468 if (PyErr_Occurred()) SWIG_fail;
39469 }
39470 {
39471 wxSize * resultptr;
39472 resultptr = new wxSize((wxSize &)(result));
39473 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39474 }
39475 return resultobj;
39476 fail:
39477 return NULL;
39478 }
39479
39480
39481 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39482 PyObject *resultobj;
39483 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39484 int arg2 ;
39485 int arg3 ;
39486 PyObject * obj0 = 0 ;
39487 PyObject * obj1 = 0 ;
39488 PyObject * obj2 = 0 ;
39489 char *kwnames[] = {
39490 (char *) "self",(char *) "x",(char *) "y", NULL
39491 };
39492
39493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39495 if (SWIG_arg_fail(1)) SWIG_fail;
39496 {
39497 arg2 = (int)(SWIG_As_int(obj1));
39498 if (SWIG_arg_fail(2)) SWIG_fail;
39499 }
39500 {
39501 arg3 = (int)(SWIG_As_int(obj2));
39502 if (SWIG_arg_fail(3)) SWIG_fail;
39503 }
39504 {
39505 PyThreadState* __tstate = wxPyBeginAllowThreads();
39506 (arg1)->SetInitSize(arg2,arg3);
39507
39508 wxPyEndAllowThreads(__tstate);
39509 if (PyErr_Occurred()) SWIG_fail;
39510 }
39511 Py_INCREF(Py_None); resultobj = Py_None;
39512 return resultobj;
39513 fail:
39514 return NULL;
39515 }
39516
39517
39518 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39519 PyObject *resultobj;
39520 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39521 int arg2 ;
39522 int arg3 ;
39523 PyObject * obj0 = 0 ;
39524 PyObject * obj1 = 0 ;
39525 PyObject * obj2 = 0 ;
39526 char *kwnames[] = {
39527 (char *) "self",(char *) "width",(char *) "height", NULL
39528 };
39529
39530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39532 if (SWIG_arg_fail(1)) SWIG_fail;
39533 {
39534 arg2 = (int)(SWIG_As_int(obj1));
39535 if (SWIG_arg_fail(2)) SWIG_fail;
39536 }
39537 {
39538 arg3 = (int)(SWIG_As_int(obj2));
39539 if (SWIG_arg_fail(3)) SWIG_fail;
39540 }
39541 {
39542 PyThreadState* __tstate = wxPyBeginAllowThreads();
39543 (arg1)->SetRatio(arg2,arg3);
39544
39545 wxPyEndAllowThreads(__tstate);
39546 if (PyErr_Occurred()) SWIG_fail;
39547 }
39548 Py_INCREF(Py_None); resultobj = Py_None;
39549 return resultobj;
39550 fail:
39551 return NULL;
39552 }
39553
39554
39555 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39556 PyObject *resultobj;
39557 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39558 wxSize *arg2 = 0 ;
39559 wxSize temp2 ;
39560 PyObject * obj0 = 0 ;
39561 PyObject * obj1 = 0 ;
39562 char *kwnames[] = {
39563 (char *) "self",(char *) "size", NULL
39564 };
39565
39566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39568 if (SWIG_arg_fail(1)) SWIG_fail;
39569 {
39570 arg2 = &temp2;
39571 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39572 }
39573 {
39574 PyThreadState* __tstate = wxPyBeginAllowThreads();
39575 (arg1)->SetRatio((wxSize const &)*arg2);
39576
39577 wxPyEndAllowThreads(__tstate);
39578 if (PyErr_Occurred()) SWIG_fail;
39579 }
39580 Py_INCREF(Py_None); resultobj = Py_None;
39581 return resultobj;
39582 fail:
39583 return NULL;
39584 }
39585
39586
39587 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39588 PyObject *resultobj;
39589 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39590 float arg2 ;
39591 PyObject * obj0 = 0 ;
39592 PyObject * obj1 = 0 ;
39593 char *kwnames[] = {
39594 (char *) "self",(char *) "ratio", NULL
39595 };
39596
39597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39599 if (SWIG_arg_fail(1)) SWIG_fail;
39600 {
39601 arg2 = (float)(SWIG_As_float(obj1));
39602 if (SWIG_arg_fail(2)) SWIG_fail;
39603 }
39604 {
39605 PyThreadState* __tstate = wxPyBeginAllowThreads();
39606 (arg1)->SetRatio(arg2);
39607
39608 wxPyEndAllowThreads(__tstate);
39609 if (PyErr_Occurred()) SWIG_fail;
39610 }
39611 Py_INCREF(Py_None); resultobj = Py_None;
39612 return resultobj;
39613 fail:
39614 return NULL;
39615 }
39616
39617
39618 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39619 PyObject *resultobj;
39620 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39621 float result;
39622 PyObject * obj0 = 0 ;
39623 char *kwnames[] = {
39624 (char *) "self", NULL
39625 };
39626
39627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39629 if (SWIG_arg_fail(1)) SWIG_fail;
39630 {
39631 PyThreadState* __tstate = wxPyBeginAllowThreads();
39632 result = (float)(arg1)->GetRatio();
39633
39634 wxPyEndAllowThreads(__tstate);
39635 if (PyErr_Occurred()) SWIG_fail;
39636 }
39637 {
39638 resultobj = SWIG_From_float((float)(result));
39639 }
39640 return resultobj;
39641 fail:
39642 return NULL;
39643 }
39644
39645
39646 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39647 PyObject *resultobj;
39648 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39649 wxRect result;
39650 PyObject * obj0 = 0 ;
39651 char *kwnames[] = {
39652 (char *) "self", NULL
39653 };
39654
39655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39657 if (SWIG_arg_fail(1)) SWIG_fail;
39658 {
39659 PyThreadState* __tstate = wxPyBeginAllowThreads();
39660 result = (arg1)->GetRect();
39661
39662 wxPyEndAllowThreads(__tstate);
39663 if (PyErr_Occurred()) SWIG_fail;
39664 }
39665 {
39666 wxRect * resultptr;
39667 resultptr = new wxRect((wxRect &)(result));
39668 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39669 }
39670 return resultobj;
39671 fail:
39672 return NULL;
39673 }
39674
39675
39676 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39677 PyObject *resultobj;
39678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39679 bool result;
39680 PyObject * obj0 = 0 ;
39681 char *kwnames[] = {
39682 (char *) "self", NULL
39683 };
39684
39685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39687 if (SWIG_arg_fail(1)) SWIG_fail;
39688 {
39689 PyThreadState* __tstate = wxPyBeginAllowThreads();
39690 result = (bool)(arg1)->IsWindow();
39691
39692 wxPyEndAllowThreads(__tstate);
39693 if (PyErr_Occurred()) SWIG_fail;
39694 }
39695 {
39696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39697 }
39698 return resultobj;
39699 fail:
39700 return NULL;
39701 }
39702
39703
39704 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39705 PyObject *resultobj;
39706 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39707 bool result;
39708 PyObject * obj0 = 0 ;
39709 char *kwnames[] = {
39710 (char *) "self", NULL
39711 };
39712
39713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39715 if (SWIG_arg_fail(1)) SWIG_fail;
39716 {
39717 PyThreadState* __tstate = wxPyBeginAllowThreads();
39718 result = (bool)(arg1)->IsSizer();
39719
39720 wxPyEndAllowThreads(__tstate);
39721 if (PyErr_Occurred()) SWIG_fail;
39722 }
39723 {
39724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39725 }
39726 return resultobj;
39727 fail:
39728 return NULL;
39729 }
39730
39731
39732 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39733 PyObject *resultobj;
39734 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39735 bool result;
39736 PyObject * obj0 = 0 ;
39737 char *kwnames[] = {
39738 (char *) "self", NULL
39739 };
39740
39741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39743 if (SWIG_arg_fail(1)) SWIG_fail;
39744 {
39745 PyThreadState* __tstate = wxPyBeginAllowThreads();
39746 result = (bool)(arg1)->IsSpacer();
39747
39748 wxPyEndAllowThreads(__tstate);
39749 if (PyErr_Occurred()) SWIG_fail;
39750 }
39751 {
39752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39753 }
39754 return resultobj;
39755 fail:
39756 return NULL;
39757 }
39758
39759
39760 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39761 PyObject *resultobj;
39762 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39763 int arg2 ;
39764 PyObject * obj0 = 0 ;
39765 PyObject * obj1 = 0 ;
39766 char *kwnames[] = {
39767 (char *) "self",(char *) "proportion", NULL
39768 };
39769
39770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39772 if (SWIG_arg_fail(1)) SWIG_fail;
39773 {
39774 arg2 = (int)(SWIG_As_int(obj1));
39775 if (SWIG_arg_fail(2)) SWIG_fail;
39776 }
39777 {
39778 PyThreadState* __tstate = wxPyBeginAllowThreads();
39779 (arg1)->SetProportion(arg2);
39780
39781 wxPyEndAllowThreads(__tstate);
39782 if (PyErr_Occurred()) SWIG_fail;
39783 }
39784 Py_INCREF(Py_None); resultobj = Py_None;
39785 return resultobj;
39786 fail:
39787 return NULL;
39788 }
39789
39790
39791 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39792 PyObject *resultobj;
39793 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39794 int result;
39795 PyObject * obj0 = 0 ;
39796 char *kwnames[] = {
39797 (char *) "self", NULL
39798 };
39799
39800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39802 if (SWIG_arg_fail(1)) SWIG_fail;
39803 {
39804 PyThreadState* __tstate = wxPyBeginAllowThreads();
39805 result = (int)(arg1)->GetProportion();
39806
39807 wxPyEndAllowThreads(__tstate);
39808 if (PyErr_Occurred()) SWIG_fail;
39809 }
39810 {
39811 resultobj = SWIG_From_int((int)(result));
39812 }
39813 return resultobj;
39814 fail:
39815 return NULL;
39816 }
39817
39818
39819 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39820 PyObject *resultobj;
39821 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39822 int arg2 ;
39823 PyObject * obj0 = 0 ;
39824 PyObject * obj1 = 0 ;
39825 char *kwnames[] = {
39826 (char *) "self",(char *) "flag", NULL
39827 };
39828
39829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39831 if (SWIG_arg_fail(1)) SWIG_fail;
39832 {
39833 arg2 = (int)(SWIG_As_int(obj1));
39834 if (SWIG_arg_fail(2)) SWIG_fail;
39835 }
39836 {
39837 PyThreadState* __tstate = wxPyBeginAllowThreads();
39838 (arg1)->SetFlag(arg2);
39839
39840 wxPyEndAllowThreads(__tstate);
39841 if (PyErr_Occurred()) SWIG_fail;
39842 }
39843 Py_INCREF(Py_None); resultobj = Py_None;
39844 return resultobj;
39845 fail:
39846 return NULL;
39847 }
39848
39849
39850 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39851 PyObject *resultobj;
39852 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39853 int result;
39854 PyObject * obj0 = 0 ;
39855 char *kwnames[] = {
39856 (char *) "self", NULL
39857 };
39858
39859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39861 if (SWIG_arg_fail(1)) SWIG_fail;
39862 {
39863 PyThreadState* __tstate = wxPyBeginAllowThreads();
39864 result = (int)(arg1)->GetFlag();
39865
39866 wxPyEndAllowThreads(__tstate);
39867 if (PyErr_Occurred()) SWIG_fail;
39868 }
39869 {
39870 resultobj = SWIG_From_int((int)(result));
39871 }
39872 return resultobj;
39873 fail:
39874 return NULL;
39875 }
39876
39877
39878 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39879 PyObject *resultobj;
39880 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39881 int arg2 ;
39882 PyObject * obj0 = 0 ;
39883 PyObject * obj1 = 0 ;
39884 char *kwnames[] = {
39885 (char *) "self",(char *) "border", NULL
39886 };
39887
39888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39890 if (SWIG_arg_fail(1)) SWIG_fail;
39891 {
39892 arg2 = (int)(SWIG_As_int(obj1));
39893 if (SWIG_arg_fail(2)) SWIG_fail;
39894 }
39895 {
39896 PyThreadState* __tstate = wxPyBeginAllowThreads();
39897 (arg1)->SetBorder(arg2);
39898
39899 wxPyEndAllowThreads(__tstate);
39900 if (PyErr_Occurred()) SWIG_fail;
39901 }
39902 Py_INCREF(Py_None); resultobj = Py_None;
39903 return resultobj;
39904 fail:
39905 return NULL;
39906 }
39907
39908
39909 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39910 PyObject *resultobj;
39911 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39912 int result;
39913 PyObject * obj0 = 0 ;
39914 char *kwnames[] = {
39915 (char *) "self", NULL
39916 };
39917
39918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39920 if (SWIG_arg_fail(1)) SWIG_fail;
39921 {
39922 PyThreadState* __tstate = wxPyBeginAllowThreads();
39923 result = (int)(arg1)->GetBorder();
39924
39925 wxPyEndAllowThreads(__tstate);
39926 if (PyErr_Occurred()) SWIG_fail;
39927 }
39928 {
39929 resultobj = SWIG_From_int((int)(result));
39930 }
39931 return resultobj;
39932 fail:
39933 return NULL;
39934 }
39935
39936
39937 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39938 PyObject *resultobj;
39939 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39940 wxWindow *result;
39941 PyObject * obj0 = 0 ;
39942 char *kwnames[] = {
39943 (char *) "self", NULL
39944 };
39945
39946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39948 if (SWIG_arg_fail(1)) SWIG_fail;
39949 {
39950 PyThreadState* __tstate = wxPyBeginAllowThreads();
39951 result = (wxWindow *)(arg1)->GetWindow();
39952
39953 wxPyEndAllowThreads(__tstate);
39954 if (PyErr_Occurred()) SWIG_fail;
39955 }
39956 {
39957 resultobj = wxPyMake_wxObject(result, 0);
39958 }
39959 return resultobj;
39960 fail:
39961 return NULL;
39962 }
39963
39964
39965 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39966 PyObject *resultobj;
39967 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39968 wxWindow *arg2 = (wxWindow *) 0 ;
39969 PyObject * obj0 = 0 ;
39970 PyObject * obj1 = 0 ;
39971 char *kwnames[] = {
39972 (char *) "self",(char *) "window", NULL
39973 };
39974
39975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39977 if (SWIG_arg_fail(1)) SWIG_fail;
39978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39979 if (SWIG_arg_fail(2)) SWIG_fail;
39980 {
39981 PyThreadState* __tstate = wxPyBeginAllowThreads();
39982 (arg1)->SetWindow(arg2);
39983
39984 wxPyEndAllowThreads(__tstate);
39985 if (PyErr_Occurred()) SWIG_fail;
39986 }
39987 Py_INCREF(Py_None); resultobj = Py_None;
39988 return resultobj;
39989 fail:
39990 return NULL;
39991 }
39992
39993
39994 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39995 PyObject *resultobj;
39996 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39997 wxSizer *result;
39998 PyObject * obj0 = 0 ;
39999 char *kwnames[] = {
40000 (char *) "self", NULL
40001 };
40002
40003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
40004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40005 if (SWIG_arg_fail(1)) SWIG_fail;
40006 {
40007 PyThreadState* __tstate = wxPyBeginAllowThreads();
40008 result = (wxSizer *)(arg1)->GetSizer();
40009
40010 wxPyEndAllowThreads(__tstate);
40011 if (PyErr_Occurred()) SWIG_fail;
40012 }
40013 {
40014 resultobj = wxPyMake_wxObject(result, 0);
40015 }
40016 return resultobj;
40017 fail:
40018 return NULL;
40019 }
40020
40021
40022 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40023 PyObject *resultobj;
40024 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40025 wxSizer *arg2 = (wxSizer *) 0 ;
40026 PyObject * obj0 = 0 ;
40027 PyObject * obj1 = 0 ;
40028 char *kwnames[] = {
40029 (char *) "self",(char *) "sizer", NULL
40030 };
40031
40032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
40033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40034 if (SWIG_arg_fail(1)) SWIG_fail;
40035 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40036 if (SWIG_arg_fail(2)) SWIG_fail;
40037 {
40038 PyThreadState* __tstate = wxPyBeginAllowThreads();
40039 (arg1)->SetSizer(arg2);
40040
40041 wxPyEndAllowThreads(__tstate);
40042 if (PyErr_Occurred()) SWIG_fail;
40043 }
40044 Py_INCREF(Py_None); resultobj = Py_None;
40045 return resultobj;
40046 fail:
40047 return NULL;
40048 }
40049
40050
40051 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40052 PyObject *resultobj;
40053 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40054 wxSize *result;
40055 PyObject * obj0 = 0 ;
40056 char *kwnames[] = {
40057 (char *) "self", NULL
40058 };
40059
40060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
40061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40062 if (SWIG_arg_fail(1)) SWIG_fail;
40063 {
40064 PyThreadState* __tstate = wxPyBeginAllowThreads();
40065 {
40066 wxSize const &_result_ref = (arg1)->GetSpacer();
40067 result = (wxSize *) &_result_ref;
40068 }
40069
40070 wxPyEndAllowThreads(__tstate);
40071 if (PyErr_Occurred()) SWIG_fail;
40072 }
40073 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40074 return resultobj;
40075 fail:
40076 return NULL;
40077 }
40078
40079
40080 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40081 PyObject *resultobj;
40082 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40083 wxSize *arg2 = 0 ;
40084 wxSize temp2 ;
40085 PyObject * obj0 = 0 ;
40086 PyObject * obj1 = 0 ;
40087 char *kwnames[] = {
40088 (char *) "self",(char *) "size", NULL
40089 };
40090
40091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
40092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40093 if (SWIG_arg_fail(1)) SWIG_fail;
40094 {
40095 arg2 = &temp2;
40096 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40097 }
40098 {
40099 PyThreadState* __tstate = wxPyBeginAllowThreads();
40100 (arg1)->SetSpacer((wxSize const &)*arg2);
40101
40102 wxPyEndAllowThreads(__tstate);
40103 if (PyErr_Occurred()) SWIG_fail;
40104 }
40105 Py_INCREF(Py_None); resultobj = Py_None;
40106 return resultobj;
40107 fail:
40108 return NULL;
40109 }
40110
40111
40112 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40113 PyObject *resultobj;
40114 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40115 bool arg2 ;
40116 PyObject * obj0 = 0 ;
40117 PyObject * obj1 = 0 ;
40118 char *kwnames[] = {
40119 (char *) "self",(char *) "show", NULL
40120 };
40121
40122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
40123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40124 if (SWIG_arg_fail(1)) SWIG_fail;
40125 {
40126 arg2 = (bool)(SWIG_As_bool(obj1));
40127 if (SWIG_arg_fail(2)) SWIG_fail;
40128 }
40129 {
40130 PyThreadState* __tstate = wxPyBeginAllowThreads();
40131 (arg1)->Show(arg2);
40132
40133 wxPyEndAllowThreads(__tstate);
40134 if (PyErr_Occurred()) SWIG_fail;
40135 }
40136 Py_INCREF(Py_None); resultobj = Py_None;
40137 return resultobj;
40138 fail:
40139 return NULL;
40140 }
40141
40142
40143 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40144 PyObject *resultobj;
40145 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40146 bool result;
40147 PyObject * obj0 = 0 ;
40148 char *kwnames[] = {
40149 (char *) "self", NULL
40150 };
40151
40152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
40153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40154 if (SWIG_arg_fail(1)) SWIG_fail;
40155 {
40156 PyThreadState* __tstate = wxPyBeginAllowThreads();
40157 result = (bool)(arg1)->IsShown();
40158
40159 wxPyEndAllowThreads(__tstate);
40160 if (PyErr_Occurred()) SWIG_fail;
40161 }
40162 {
40163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40164 }
40165 return resultobj;
40166 fail:
40167 return NULL;
40168 }
40169
40170
40171 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40172 PyObject *resultobj;
40173 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40174 wxPoint result;
40175 PyObject * obj0 = 0 ;
40176 char *kwnames[] = {
40177 (char *) "self", NULL
40178 };
40179
40180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40182 if (SWIG_arg_fail(1)) SWIG_fail;
40183 {
40184 PyThreadState* __tstate = wxPyBeginAllowThreads();
40185 result = (arg1)->GetPosition();
40186
40187 wxPyEndAllowThreads(__tstate);
40188 if (PyErr_Occurred()) SWIG_fail;
40189 }
40190 {
40191 wxPoint * resultptr;
40192 resultptr = new wxPoint((wxPoint &)(result));
40193 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40194 }
40195 return resultobj;
40196 fail:
40197 return NULL;
40198 }
40199
40200
40201 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40202 PyObject *resultobj;
40203 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40204 PyObject *result;
40205 PyObject * obj0 = 0 ;
40206 char *kwnames[] = {
40207 (char *) "self", NULL
40208 };
40209
40210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40212 if (SWIG_arg_fail(1)) SWIG_fail;
40213 {
40214 PyThreadState* __tstate = wxPyBeginAllowThreads();
40215 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40216
40217 wxPyEndAllowThreads(__tstate);
40218 if (PyErr_Occurred()) SWIG_fail;
40219 }
40220 resultobj = result;
40221 return resultobj;
40222 fail:
40223 return NULL;
40224 }
40225
40226
40227 static PyObject *_wrap_SizerItem_SetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40228 PyObject *resultobj;
40229 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40230 PyObject *arg2 = (PyObject *) 0 ;
40231 PyObject * obj0 = 0 ;
40232 PyObject * obj1 = 0 ;
40233 char *kwnames[] = {
40234 (char *) "self",(char *) "userData", NULL
40235 };
40236
40237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) goto fail;
40238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40239 if (SWIG_arg_fail(1)) SWIG_fail;
40240 arg2 = obj1;
40241 {
40242 PyThreadState* __tstate = wxPyBeginAllowThreads();
40243 wxSizerItem_SetUserData(arg1,arg2);
40244
40245 wxPyEndAllowThreads(__tstate);
40246 if (PyErr_Occurred()) SWIG_fail;
40247 }
40248 Py_INCREF(Py_None); resultobj = Py_None;
40249 return resultobj;
40250 fail:
40251 return NULL;
40252 }
40253
40254
40255 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40256 PyObject *obj;
40257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40258 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40259 Py_INCREF(obj);
40260 return Py_BuildValue((char *)"");
40261 }
40262 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40263 PyObject *resultobj;
40264 wxSizer *arg1 = (wxSizer *) 0 ;
40265 PyObject *arg2 = (PyObject *) 0 ;
40266 PyObject * obj0 = 0 ;
40267 PyObject * obj1 = 0 ;
40268 char *kwnames[] = {
40269 (char *) "self",(char *) "_self", NULL
40270 };
40271
40272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40274 if (SWIG_arg_fail(1)) SWIG_fail;
40275 arg2 = obj1;
40276 {
40277 PyThreadState* __tstate = wxPyBeginAllowThreads();
40278 wxSizer__setOORInfo(arg1,arg2);
40279
40280 wxPyEndAllowThreads(__tstate);
40281 if (PyErr_Occurred()) SWIG_fail;
40282 }
40283 Py_INCREF(Py_None); resultobj = Py_None;
40284 return resultobj;
40285 fail:
40286 return NULL;
40287 }
40288
40289
40290 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40291 PyObject *resultobj;
40292 wxSizer *arg1 = (wxSizer *) 0 ;
40293 PyObject *arg2 = (PyObject *) 0 ;
40294 int arg3 = (int) 0 ;
40295 int arg4 = (int) 0 ;
40296 int arg5 = (int) 0 ;
40297 PyObject *arg6 = (PyObject *) NULL ;
40298 wxSizerItem *result;
40299 PyObject * obj0 = 0 ;
40300 PyObject * obj1 = 0 ;
40301 PyObject * obj2 = 0 ;
40302 PyObject * obj3 = 0 ;
40303 PyObject * obj4 = 0 ;
40304 PyObject * obj5 = 0 ;
40305 char *kwnames[] = {
40306 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40307 };
40308
40309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40311 if (SWIG_arg_fail(1)) SWIG_fail;
40312 arg2 = obj1;
40313 if (obj2) {
40314 {
40315 arg3 = (int)(SWIG_As_int(obj2));
40316 if (SWIG_arg_fail(3)) SWIG_fail;
40317 }
40318 }
40319 if (obj3) {
40320 {
40321 arg4 = (int)(SWIG_As_int(obj3));
40322 if (SWIG_arg_fail(4)) SWIG_fail;
40323 }
40324 }
40325 if (obj4) {
40326 {
40327 arg5 = (int)(SWIG_As_int(obj4));
40328 if (SWIG_arg_fail(5)) SWIG_fail;
40329 }
40330 }
40331 if (obj5) {
40332 arg6 = obj5;
40333 }
40334 {
40335 PyThreadState* __tstate = wxPyBeginAllowThreads();
40336 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40337
40338 wxPyEndAllowThreads(__tstate);
40339 if (PyErr_Occurred()) SWIG_fail;
40340 }
40341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40342 return resultobj;
40343 fail:
40344 return NULL;
40345 }
40346
40347
40348 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40349 PyObject *resultobj;
40350 wxSizer *arg1 = (wxSizer *) 0 ;
40351 int arg2 ;
40352 PyObject *arg3 = (PyObject *) 0 ;
40353 int arg4 = (int) 0 ;
40354 int arg5 = (int) 0 ;
40355 int arg6 = (int) 0 ;
40356 PyObject *arg7 = (PyObject *) NULL ;
40357 wxSizerItem *result;
40358 PyObject * obj0 = 0 ;
40359 PyObject * obj1 = 0 ;
40360 PyObject * obj2 = 0 ;
40361 PyObject * obj3 = 0 ;
40362 PyObject * obj4 = 0 ;
40363 PyObject * obj5 = 0 ;
40364 PyObject * obj6 = 0 ;
40365 char *kwnames[] = {
40366 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40367 };
40368
40369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40371 if (SWIG_arg_fail(1)) SWIG_fail;
40372 {
40373 arg2 = (int)(SWIG_As_int(obj1));
40374 if (SWIG_arg_fail(2)) SWIG_fail;
40375 }
40376 arg3 = obj2;
40377 if (obj3) {
40378 {
40379 arg4 = (int)(SWIG_As_int(obj3));
40380 if (SWIG_arg_fail(4)) SWIG_fail;
40381 }
40382 }
40383 if (obj4) {
40384 {
40385 arg5 = (int)(SWIG_As_int(obj4));
40386 if (SWIG_arg_fail(5)) SWIG_fail;
40387 }
40388 }
40389 if (obj5) {
40390 {
40391 arg6 = (int)(SWIG_As_int(obj5));
40392 if (SWIG_arg_fail(6)) SWIG_fail;
40393 }
40394 }
40395 if (obj6) {
40396 arg7 = obj6;
40397 }
40398 {
40399 PyThreadState* __tstate = wxPyBeginAllowThreads();
40400 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40401
40402 wxPyEndAllowThreads(__tstate);
40403 if (PyErr_Occurred()) SWIG_fail;
40404 }
40405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40406 return resultobj;
40407 fail:
40408 return NULL;
40409 }
40410
40411
40412 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40413 PyObject *resultobj;
40414 wxSizer *arg1 = (wxSizer *) 0 ;
40415 PyObject *arg2 = (PyObject *) 0 ;
40416 int arg3 = (int) 0 ;
40417 int arg4 = (int) 0 ;
40418 int arg5 = (int) 0 ;
40419 PyObject *arg6 = (PyObject *) NULL ;
40420 wxSizerItem *result;
40421 PyObject * obj0 = 0 ;
40422 PyObject * obj1 = 0 ;
40423 PyObject * obj2 = 0 ;
40424 PyObject * obj3 = 0 ;
40425 PyObject * obj4 = 0 ;
40426 PyObject * obj5 = 0 ;
40427 char *kwnames[] = {
40428 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40429 };
40430
40431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40433 if (SWIG_arg_fail(1)) SWIG_fail;
40434 arg2 = obj1;
40435 if (obj2) {
40436 {
40437 arg3 = (int)(SWIG_As_int(obj2));
40438 if (SWIG_arg_fail(3)) SWIG_fail;
40439 }
40440 }
40441 if (obj3) {
40442 {
40443 arg4 = (int)(SWIG_As_int(obj3));
40444 if (SWIG_arg_fail(4)) SWIG_fail;
40445 }
40446 }
40447 if (obj4) {
40448 {
40449 arg5 = (int)(SWIG_As_int(obj4));
40450 if (SWIG_arg_fail(5)) SWIG_fail;
40451 }
40452 }
40453 if (obj5) {
40454 arg6 = obj5;
40455 }
40456 {
40457 PyThreadState* __tstate = wxPyBeginAllowThreads();
40458 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40459
40460 wxPyEndAllowThreads(__tstate);
40461 if (PyErr_Occurred()) SWIG_fail;
40462 }
40463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40464 return resultobj;
40465 fail:
40466 return NULL;
40467 }
40468
40469
40470 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40471 PyObject *resultobj;
40472 wxSizer *arg1 = (wxSizer *) 0 ;
40473 PyObject *arg2 = (PyObject *) 0 ;
40474 bool result;
40475 PyObject * obj0 = 0 ;
40476 PyObject * obj1 = 0 ;
40477 char *kwnames[] = {
40478 (char *) "self",(char *) "item", NULL
40479 };
40480
40481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40483 if (SWIG_arg_fail(1)) SWIG_fail;
40484 arg2 = obj1;
40485 {
40486 PyThreadState* __tstate = wxPyBeginAllowThreads();
40487 result = (bool)wxSizer_Remove(arg1,arg2);
40488
40489 wxPyEndAllowThreads(__tstate);
40490 if (PyErr_Occurred()) SWIG_fail;
40491 }
40492 {
40493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40494 }
40495 return resultobj;
40496 fail:
40497 return NULL;
40498 }
40499
40500
40501 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40502 PyObject *resultobj;
40503 wxSizer *arg1 = (wxSizer *) 0 ;
40504 PyObject *arg2 = (PyObject *) 0 ;
40505 bool result;
40506 PyObject * obj0 = 0 ;
40507 PyObject * obj1 = 0 ;
40508 char *kwnames[] = {
40509 (char *) "self",(char *) "item", NULL
40510 };
40511
40512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40514 if (SWIG_arg_fail(1)) SWIG_fail;
40515 arg2 = obj1;
40516 {
40517 PyThreadState* __tstate = wxPyBeginAllowThreads();
40518 result = (bool)wxSizer_Detach(arg1,arg2);
40519
40520 wxPyEndAllowThreads(__tstate);
40521 if (PyErr_Occurred()) SWIG_fail;
40522 }
40523 {
40524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40525 }
40526 return resultobj;
40527 fail:
40528 return NULL;
40529 }
40530
40531
40532 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40533 PyObject *resultobj;
40534 wxSizer *arg1 = (wxSizer *) 0 ;
40535 PyObject *arg2 = (PyObject *) 0 ;
40536 wxSizerItem *result;
40537 PyObject * obj0 = 0 ;
40538 PyObject * obj1 = 0 ;
40539 char *kwnames[] = {
40540 (char *) "self",(char *) "item", NULL
40541 };
40542
40543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40545 if (SWIG_arg_fail(1)) SWIG_fail;
40546 arg2 = obj1;
40547 {
40548 PyThreadState* __tstate = wxPyBeginAllowThreads();
40549 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40550
40551 wxPyEndAllowThreads(__tstate);
40552 if (PyErr_Occurred()) SWIG_fail;
40553 }
40554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40555 return resultobj;
40556 fail:
40557 return NULL;
40558 }
40559
40560
40561 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40562 PyObject *resultobj;
40563 wxSizer *arg1 = (wxSizer *) 0 ;
40564 PyObject *arg2 = (PyObject *) 0 ;
40565 wxSize *arg3 = 0 ;
40566 wxSize temp3 ;
40567 PyObject * obj0 = 0 ;
40568 PyObject * obj1 = 0 ;
40569 PyObject * obj2 = 0 ;
40570 char *kwnames[] = {
40571 (char *) "self",(char *) "item",(char *) "size", NULL
40572 };
40573
40574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40576 if (SWIG_arg_fail(1)) SWIG_fail;
40577 arg2 = obj1;
40578 {
40579 arg3 = &temp3;
40580 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40581 }
40582 {
40583 PyThreadState* __tstate = wxPyBeginAllowThreads();
40584 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40585
40586 wxPyEndAllowThreads(__tstate);
40587 if (PyErr_Occurred()) SWIG_fail;
40588 }
40589 Py_INCREF(Py_None); resultobj = Py_None;
40590 return resultobj;
40591 fail:
40592 return NULL;
40593 }
40594
40595
40596 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40597 PyObject *resultobj;
40598 wxSizer *arg1 = (wxSizer *) 0 ;
40599 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40600 wxSizerItem *result;
40601 PyObject * obj0 = 0 ;
40602 PyObject * obj1 = 0 ;
40603 char *kwnames[] = {
40604 (char *) "self",(char *) "item", NULL
40605 };
40606
40607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40609 if (SWIG_arg_fail(1)) SWIG_fail;
40610 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40611 if (SWIG_arg_fail(2)) SWIG_fail;
40612 {
40613 PyThreadState* __tstate = wxPyBeginAllowThreads();
40614 result = (wxSizerItem *)(arg1)->Add(arg2);
40615
40616 wxPyEndAllowThreads(__tstate);
40617 if (PyErr_Occurred()) SWIG_fail;
40618 }
40619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40620 return resultobj;
40621 fail:
40622 return NULL;
40623 }
40624
40625
40626 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40627 PyObject *resultobj;
40628 wxSizer *arg1 = (wxSizer *) 0 ;
40629 size_t arg2 ;
40630 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40631 wxSizerItem *result;
40632 PyObject * obj0 = 0 ;
40633 PyObject * obj1 = 0 ;
40634 PyObject * obj2 = 0 ;
40635 char *kwnames[] = {
40636 (char *) "self",(char *) "index",(char *) "item", NULL
40637 };
40638
40639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40641 if (SWIG_arg_fail(1)) SWIG_fail;
40642 {
40643 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40644 if (SWIG_arg_fail(2)) SWIG_fail;
40645 }
40646 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40647 if (SWIG_arg_fail(3)) SWIG_fail;
40648 {
40649 PyThreadState* __tstate = wxPyBeginAllowThreads();
40650 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40651
40652 wxPyEndAllowThreads(__tstate);
40653 if (PyErr_Occurred()) SWIG_fail;
40654 }
40655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40656 return resultobj;
40657 fail:
40658 return NULL;
40659 }
40660
40661
40662 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40663 PyObject *resultobj;
40664 wxSizer *arg1 = (wxSizer *) 0 ;
40665 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40666 wxSizerItem *result;
40667 PyObject * obj0 = 0 ;
40668 PyObject * obj1 = 0 ;
40669 char *kwnames[] = {
40670 (char *) "self",(char *) "item", NULL
40671 };
40672
40673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40675 if (SWIG_arg_fail(1)) SWIG_fail;
40676 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40677 if (SWIG_arg_fail(2)) SWIG_fail;
40678 {
40679 PyThreadState* __tstate = wxPyBeginAllowThreads();
40680 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40681
40682 wxPyEndAllowThreads(__tstate);
40683 if (PyErr_Occurred()) SWIG_fail;
40684 }
40685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40686 return resultobj;
40687 fail:
40688 return NULL;
40689 }
40690
40691
40692 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40693 PyObject *resultobj;
40694 wxSizer *arg1 = (wxSizer *) 0 ;
40695 int arg2 ;
40696 int arg3 ;
40697 int arg4 ;
40698 int arg5 ;
40699 PyObject * obj0 = 0 ;
40700 PyObject * obj1 = 0 ;
40701 PyObject * obj2 = 0 ;
40702 PyObject * obj3 = 0 ;
40703 PyObject * obj4 = 0 ;
40704 char *kwnames[] = {
40705 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40706 };
40707
40708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40710 if (SWIG_arg_fail(1)) SWIG_fail;
40711 {
40712 arg2 = (int)(SWIG_As_int(obj1));
40713 if (SWIG_arg_fail(2)) SWIG_fail;
40714 }
40715 {
40716 arg3 = (int)(SWIG_As_int(obj2));
40717 if (SWIG_arg_fail(3)) SWIG_fail;
40718 }
40719 {
40720 arg4 = (int)(SWIG_As_int(obj3));
40721 if (SWIG_arg_fail(4)) SWIG_fail;
40722 }
40723 {
40724 arg5 = (int)(SWIG_As_int(obj4));
40725 if (SWIG_arg_fail(5)) SWIG_fail;
40726 }
40727 {
40728 PyThreadState* __tstate = wxPyBeginAllowThreads();
40729 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40730
40731 wxPyEndAllowThreads(__tstate);
40732 if (PyErr_Occurred()) SWIG_fail;
40733 }
40734 Py_INCREF(Py_None); resultobj = Py_None;
40735 return resultobj;
40736 fail:
40737 return NULL;
40738 }
40739
40740
40741 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40742 PyObject *resultobj;
40743 wxSizer *arg1 = (wxSizer *) 0 ;
40744 wxSize *arg2 = 0 ;
40745 wxSize temp2 ;
40746 PyObject * obj0 = 0 ;
40747 PyObject * obj1 = 0 ;
40748 char *kwnames[] = {
40749 (char *) "self",(char *) "size", NULL
40750 };
40751
40752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40754 if (SWIG_arg_fail(1)) SWIG_fail;
40755 {
40756 arg2 = &temp2;
40757 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40758 }
40759 {
40760 PyThreadState* __tstate = wxPyBeginAllowThreads();
40761 (arg1)->SetMinSize((wxSize const &)*arg2);
40762
40763 wxPyEndAllowThreads(__tstate);
40764 if (PyErr_Occurred()) SWIG_fail;
40765 }
40766 Py_INCREF(Py_None); resultobj = Py_None;
40767 return resultobj;
40768 fail:
40769 return NULL;
40770 }
40771
40772
40773 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40774 PyObject *resultobj;
40775 wxSizer *arg1 = (wxSizer *) 0 ;
40776 wxSize result;
40777 PyObject * obj0 = 0 ;
40778 char *kwnames[] = {
40779 (char *) "self", NULL
40780 };
40781
40782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40784 if (SWIG_arg_fail(1)) SWIG_fail;
40785 {
40786 PyThreadState* __tstate = wxPyBeginAllowThreads();
40787 result = (arg1)->GetSize();
40788
40789 wxPyEndAllowThreads(__tstate);
40790 if (PyErr_Occurred()) SWIG_fail;
40791 }
40792 {
40793 wxSize * resultptr;
40794 resultptr = new wxSize((wxSize &)(result));
40795 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40796 }
40797 return resultobj;
40798 fail:
40799 return NULL;
40800 }
40801
40802
40803 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40804 PyObject *resultobj;
40805 wxSizer *arg1 = (wxSizer *) 0 ;
40806 wxPoint result;
40807 PyObject * obj0 = 0 ;
40808 char *kwnames[] = {
40809 (char *) "self", NULL
40810 };
40811
40812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40814 if (SWIG_arg_fail(1)) SWIG_fail;
40815 {
40816 PyThreadState* __tstate = wxPyBeginAllowThreads();
40817 result = (arg1)->GetPosition();
40818
40819 wxPyEndAllowThreads(__tstate);
40820 if (PyErr_Occurred()) SWIG_fail;
40821 }
40822 {
40823 wxPoint * resultptr;
40824 resultptr = new wxPoint((wxPoint &)(result));
40825 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40826 }
40827 return resultobj;
40828 fail:
40829 return NULL;
40830 }
40831
40832
40833 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40834 PyObject *resultobj;
40835 wxSizer *arg1 = (wxSizer *) 0 ;
40836 wxSize result;
40837 PyObject * obj0 = 0 ;
40838 char *kwnames[] = {
40839 (char *) "self", NULL
40840 };
40841
40842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40844 if (SWIG_arg_fail(1)) SWIG_fail;
40845 {
40846 PyThreadState* __tstate = wxPyBeginAllowThreads();
40847 result = (arg1)->GetMinSize();
40848
40849 wxPyEndAllowThreads(__tstate);
40850 if (PyErr_Occurred()) SWIG_fail;
40851 }
40852 {
40853 wxSize * resultptr;
40854 resultptr = new wxSize((wxSize &)(result));
40855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40856 }
40857 return resultobj;
40858 fail:
40859 return NULL;
40860 }
40861
40862
40863 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40864 PyObject *resultobj;
40865 wxSizer *arg1 = (wxSizer *) 0 ;
40866 PyObject * obj0 = 0 ;
40867 char *kwnames[] = {
40868 (char *) "self", NULL
40869 };
40870
40871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40873 if (SWIG_arg_fail(1)) SWIG_fail;
40874 {
40875 PyThreadState* __tstate = wxPyBeginAllowThreads();
40876 (arg1)->RecalcSizes();
40877
40878 wxPyEndAllowThreads(__tstate);
40879 if (PyErr_Occurred()) SWIG_fail;
40880 }
40881 Py_INCREF(Py_None); resultobj = Py_None;
40882 return resultobj;
40883 fail:
40884 return NULL;
40885 }
40886
40887
40888 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40889 PyObject *resultobj;
40890 wxSizer *arg1 = (wxSizer *) 0 ;
40891 wxSize result;
40892 PyObject * obj0 = 0 ;
40893 char *kwnames[] = {
40894 (char *) "self", NULL
40895 };
40896
40897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40899 if (SWIG_arg_fail(1)) SWIG_fail;
40900 {
40901 PyThreadState* __tstate = wxPyBeginAllowThreads();
40902 result = (arg1)->CalcMin();
40903
40904 wxPyEndAllowThreads(__tstate);
40905 if (PyErr_Occurred()) SWIG_fail;
40906 }
40907 {
40908 wxSize * resultptr;
40909 resultptr = new wxSize((wxSize &)(result));
40910 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40911 }
40912 return resultobj;
40913 fail:
40914 return NULL;
40915 }
40916
40917
40918 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40919 PyObject *resultobj;
40920 wxSizer *arg1 = (wxSizer *) 0 ;
40921 PyObject * obj0 = 0 ;
40922 char *kwnames[] = {
40923 (char *) "self", NULL
40924 };
40925
40926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40928 if (SWIG_arg_fail(1)) SWIG_fail;
40929 {
40930 PyThreadState* __tstate = wxPyBeginAllowThreads();
40931 (arg1)->Layout();
40932
40933 wxPyEndAllowThreads(__tstate);
40934 if (PyErr_Occurred()) SWIG_fail;
40935 }
40936 Py_INCREF(Py_None); resultobj = Py_None;
40937 return resultobj;
40938 fail:
40939 return NULL;
40940 }
40941
40942
40943 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40944 PyObject *resultobj;
40945 wxSizer *arg1 = (wxSizer *) 0 ;
40946 wxWindow *arg2 = (wxWindow *) 0 ;
40947 wxSize result;
40948 PyObject * obj0 = 0 ;
40949 PyObject * obj1 = 0 ;
40950 char *kwnames[] = {
40951 (char *) "self",(char *) "window", NULL
40952 };
40953
40954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40956 if (SWIG_arg_fail(1)) SWIG_fail;
40957 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40958 if (SWIG_arg_fail(2)) SWIG_fail;
40959 {
40960 PyThreadState* __tstate = wxPyBeginAllowThreads();
40961 result = (arg1)->Fit(arg2);
40962
40963 wxPyEndAllowThreads(__tstate);
40964 if (PyErr_Occurred()) SWIG_fail;
40965 }
40966 {
40967 wxSize * resultptr;
40968 resultptr = new wxSize((wxSize &)(result));
40969 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40970 }
40971 return resultobj;
40972 fail:
40973 return NULL;
40974 }
40975
40976
40977 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40978 PyObject *resultobj;
40979 wxSizer *arg1 = (wxSizer *) 0 ;
40980 wxWindow *arg2 = (wxWindow *) 0 ;
40981 PyObject * obj0 = 0 ;
40982 PyObject * obj1 = 0 ;
40983 char *kwnames[] = {
40984 (char *) "self",(char *) "window", NULL
40985 };
40986
40987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40989 if (SWIG_arg_fail(1)) SWIG_fail;
40990 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40991 if (SWIG_arg_fail(2)) SWIG_fail;
40992 {
40993 PyThreadState* __tstate = wxPyBeginAllowThreads();
40994 (arg1)->FitInside(arg2);
40995
40996 wxPyEndAllowThreads(__tstate);
40997 if (PyErr_Occurred()) SWIG_fail;
40998 }
40999 Py_INCREF(Py_None); resultobj = Py_None;
41000 return resultobj;
41001 fail:
41002 return NULL;
41003 }
41004
41005
41006 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41007 PyObject *resultobj;
41008 wxSizer *arg1 = (wxSizer *) 0 ;
41009 wxWindow *arg2 = (wxWindow *) 0 ;
41010 PyObject * obj0 = 0 ;
41011 PyObject * obj1 = 0 ;
41012 char *kwnames[] = {
41013 (char *) "self",(char *) "window", NULL
41014 };
41015
41016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
41017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41018 if (SWIG_arg_fail(1)) SWIG_fail;
41019 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41020 if (SWIG_arg_fail(2)) SWIG_fail;
41021 {
41022 PyThreadState* __tstate = wxPyBeginAllowThreads();
41023 (arg1)->SetSizeHints(arg2);
41024
41025 wxPyEndAllowThreads(__tstate);
41026 if (PyErr_Occurred()) SWIG_fail;
41027 }
41028 Py_INCREF(Py_None); resultobj = Py_None;
41029 return resultobj;
41030 fail:
41031 return NULL;
41032 }
41033
41034
41035 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41036 PyObject *resultobj;
41037 wxSizer *arg1 = (wxSizer *) 0 ;
41038 wxWindow *arg2 = (wxWindow *) 0 ;
41039 PyObject * obj0 = 0 ;
41040 PyObject * obj1 = 0 ;
41041 char *kwnames[] = {
41042 (char *) "self",(char *) "window", NULL
41043 };
41044
41045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
41046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41047 if (SWIG_arg_fail(1)) SWIG_fail;
41048 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41049 if (SWIG_arg_fail(2)) SWIG_fail;
41050 {
41051 PyThreadState* __tstate = wxPyBeginAllowThreads();
41052 (arg1)->SetVirtualSizeHints(arg2);
41053
41054 wxPyEndAllowThreads(__tstate);
41055 if (PyErr_Occurred()) SWIG_fail;
41056 }
41057 Py_INCREF(Py_None); resultobj = Py_None;
41058 return resultobj;
41059 fail:
41060 return NULL;
41061 }
41062
41063
41064 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
41065 PyObject *resultobj;
41066 wxSizer *arg1 = (wxSizer *) 0 ;
41067 bool arg2 = (bool) false ;
41068 PyObject * obj0 = 0 ;
41069 PyObject * obj1 = 0 ;
41070 char *kwnames[] = {
41071 (char *) "self",(char *) "deleteWindows", NULL
41072 };
41073
41074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
41075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41076 if (SWIG_arg_fail(1)) SWIG_fail;
41077 if (obj1) {
41078 {
41079 arg2 = (bool)(SWIG_As_bool(obj1));
41080 if (SWIG_arg_fail(2)) SWIG_fail;
41081 }
41082 }
41083 {
41084 PyThreadState* __tstate = wxPyBeginAllowThreads();
41085 (arg1)->Clear(arg2);
41086
41087 wxPyEndAllowThreads(__tstate);
41088 if (PyErr_Occurred()) SWIG_fail;
41089 }
41090 Py_INCREF(Py_None); resultobj = Py_None;
41091 return resultobj;
41092 fail:
41093 return NULL;
41094 }
41095
41096
41097 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41098 PyObject *resultobj;
41099 wxSizer *arg1 = (wxSizer *) 0 ;
41100 PyObject * obj0 = 0 ;
41101 char *kwnames[] = {
41102 (char *) "self", NULL
41103 };
41104
41105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41107 if (SWIG_arg_fail(1)) SWIG_fail;
41108 {
41109 PyThreadState* __tstate = wxPyBeginAllowThreads();
41110 (arg1)->DeleteWindows();
41111
41112 wxPyEndAllowThreads(__tstate);
41113 if (PyErr_Occurred()) SWIG_fail;
41114 }
41115 Py_INCREF(Py_None); resultobj = Py_None;
41116 return resultobj;
41117 fail:
41118 return NULL;
41119 }
41120
41121
41122 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41123 PyObject *resultobj;
41124 wxSizer *arg1 = (wxSizer *) 0 ;
41125 PyObject *result;
41126 PyObject * obj0 = 0 ;
41127 char *kwnames[] = {
41128 (char *) "self", NULL
41129 };
41130
41131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41133 if (SWIG_arg_fail(1)) SWIG_fail;
41134 {
41135 PyThreadState* __tstate = wxPyBeginAllowThreads();
41136 result = (PyObject *)wxSizer_GetChildren(arg1);
41137
41138 wxPyEndAllowThreads(__tstate);
41139 if (PyErr_Occurred()) SWIG_fail;
41140 }
41141 resultobj = result;
41142 return resultobj;
41143 fail:
41144 return NULL;
41145 }
41146
41147
41148 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41149 PyObject *resultobj;
41150 wxSizer *arg1 = (wxSizer *) 0 ;
41151 PyObject *arg2 = (PyObject *) 0 ;
41152 bool arg3 = (bool) true ;
41153 bool arg4 = (bool) false ;
41154 bool result;
41155 PyObject * obj0 = 0 ;
41156 PyObject * obj1 = 0 ;
41157 PyObject * obj2 = 0 ;
41158 PyObject * obj3 = 0 ;
41159 char *kwnames[] = {
41160 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41161 };
41162
41163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41165 if (SWIG_arg_fail(1)) SWIG_fail;
41166 arg2 = obj1;
41167 if (obj2) {
41168 {
41169 arg3 = (bool)(SWIG_As_bool(obj2));
41170 if (SWIG_arg_fail(3)) SWIG_fail;
41171 }
41172 }
41173 if (obj3) {
41174 {
41175 arg4 = (bool)(SWIG_As_bool(obj3));
41176 if (SWIG_arg_fail(4)) SWIG_fail;
41177 }
41178 }
41179 {
41180 PyThreadState* __tstate = wxPyBeginAllowThreads();
41181 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41182
41183 wxPyEndAllowThreads(__tstate);
41184 if (PyErr_Occurred()) SWIG_fail;
41185 }
41186 {
41187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41188 }
41189 return resultobj;
41190 fail:
41191 return NULL;
41192 }
41193
41194
41195 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41196 PyObject *resultobj;
41197 wxSizer *arg1 = (wxSizer *) 0 ;
41198 PyObject *arg2 = (PyObject *) 0 ;
41199 bool result;
41200 PyObject * obj0 = 0 ;
41201 PyObject * obj1 = 0 ;
41202 char *kwnames[] = {
41203 (char *) "self",(char *) "item", NULL
41204 };
41205
41206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41208 if (SWIG_arg_fail(1)) SWIG_fail;
41209 arg2 = obj1;
41210 {
41211 PyThreadState* __tstate = wxPyBeginAllowThreads();
41212 result = (bool)wxSizer_IsShown(arg1,arg2);
41213
41214 wxPyEndAllowThreads(__tstate);
41215 if (PyErr_Occurred()) SWIG_fail;
41216 }
41217 {
41218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41219 }
41220 return resultobj;
41221 fail:
41222 return NULL;
41223 }
41224
41225
41226 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41227 PyObject *resultobj;
41228 wxSizer *arg1 = (wxSizer *) 0 ;
41229 bool arg2 ;
41230 PyObject * obj0 = 0 ;
41231 PyObject * obj1 = 0 ;
41232 char *kwnames[] = {
41233 (char *) "self",(char *) "show", NULL
41234 };
41235
41236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41238 if (SWIG_arg_fail(1)) SWIG_fail;
41239 {
41240 arg2 = (bool)(SWIG_As_bool(obj1));
41241 if (SWIG_arg_fail(2)) SWIG_fail;
41242 }
41243 {
41244 PyThreadState* __tstate = wxPyBeginAllowThreads();
41245 (arg1)->ShowItems(arg2);
41246
41247 wxPyEndAllowThreads(__tstate);
41248 if (PyErr_Occurred()) SWIG_fail;
41249 }
41250 Py_INCREF(Py_None); resultobj = Py_None;
41251 return resultobj;
41252 fail:
41253 return NULL;
41254 }
41255
41256
41257 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41258 PyObject *obj;
41259 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41260 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41261 Py_INCREF(obj);
41262 return Py_BuildValue((char *)"");
41263 }
41264 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41265 PyObject *resultobj;
41266 wxPySizer *result;
41267 char *kwnames[] = {
41268 NULL
41269 };
41270
41271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41272 {
41273 PyThreadState* __tstate = wxPyBeginAllowThreads();
41274 result = (wxPySizer *)new wxPySizer();
41275
41276 wxPyEndAllowThreads(__tstate);
41277 if (PyErr_Occurred()) SWIG_fail;
41278 }
41279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41280 return resultobj;
41281 fail:
41282 return NULL;
41283 }
41284
41285
41286 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41287 PyObject *resultobj;
41288 wxPySizer *arg1 = (wxPySizer *) 0 ;
41289 PyObject *arg2 = (PyObject *) 0 ;
41290 PyObject *arg3 = (PyObject *) 0 ;
41291 PyObject * obj0 = 0 ;
41292 PyObject * obj1 = 0 ;
41293 PyObject * obj2 = 0 ;
41294 char *kwnames[] = {
41295 (char *) "self",(char *) "self",(char *) "_class", NULL
41296 };
41297
41298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41300 if (SWIG_arg_fail(1)) SWIG_fail;
41301 arg2 = obj1;
41302 arg3 = obj2;
41303 {
41304 PyThreadState* __tstate = wxPyBeginAllowThreads();
41305 (arg1)->_setCallbackInfo(arg2,arg3);
41306
41307 wxPyEndAllowThreads(__tstate);
41308 if (PyErr_Occurred()) SWIG_fail;
41309 }
41310 Py_INCREF(Py_None); resultobj = Py_None;
41311 return resultobj;
41312 fail:
41313 return NULL;
41314 }
41315
41316
41317 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41318 PyObject *obj;
41319 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41320 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41321 Py_INCREF(obj);
41322 return Py_BuildValue((char *)"");
41323 }
41324 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41325 PyObject *resultobj;
41326 int arg1 = (int) wxHORIZONTAL ;
41327 wxBoxSizer *result;
41328 PyObject * obj0 = 0 ;
41329 char *kwnames[] = {
41330 (char *) "orient", NULL
41331 };
41332
41333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41334 if (obj0) {
41335 {
41336 arg1 = (int)(SWIG_As_int(obj0));
41337 if (SWIG_arg_fail(1)) SWIG_fail;
41338 }
41339 }
41340 {
41341 PyThreadState* __tstate = wxPyBeginAllowThreads();
41342 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41343
41344 wxPyEndAllowThreads(__tstate);
41345 if (PyErr_Occurred()) SWIG_fail;
41346 }
41347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41348 return resultobj;
41349 fail:
41350 return NULL;
41351 }
41352
41353
41354 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41355 PyObject *resultobj;
41356 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41357 int result;
41358 PyObject * obj0 = 0 ;
41359 char *kwnames[] = {
41360 (char *) "self", NULL
41361 };
41362
41363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41365 if (SWIG_arg_fail(1)) SWIG_fail;
41366 {
41367 PyThreadState* __tstate = wxPyBeginAllowThreads();
41368 result = (int)(arg1)->GetOrientation();
41369
41370 wxPyEndAllowThreads(__tstate);
41371 if (PyErr_Occurred()) SWIG_fail;
41372 }
41373 {
41374 resultobj = SWIG_From_int((int)(result));
41375 }
41376 return resultobj;
41377 fail:
41378 return NULL;
41379 }
41380
41381
41382 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41383 PyObject *resultobj;
41384 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41385 int arg2 ;
41386 PyObject * obj0 = 0 ;
41387 PyObject * obj1 = 0 ;
41388 char *kwnames[] = {
41389 (char *) "self",(char *) "orient", NULL
41390 };
41391
41392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41394 if (SWIG_arg_fail(1)) SWIG_fail;
41395 {
41396 arg2 = (int)(SWIG_As_int(obj1));
41397 if (SWIG_arg_fail(2)) SWIG_fail;
41398 }
41399 {
41400 PyThreadState* __tstate = wxPyBeginAllowThreads();
41401 (arg1)->SetOrientation(arg2);
41402
41403 wxPyEndAllowThreads(__tstate);
41404 if (PyErr_Occurred()) SWIG_fail;
41405 }
41406 Py_INCREF(Py_None); resultobj = Py_None;
41407 return resultobj;
41408 fail:
41409 return NULL;
41410 }
41411
41412
41413 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41414 PyObject *obj;
41415 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41416 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41417 Py_INCREF(obj);
41418 return Py_BuildValue((char *)"");
41419 }
41420 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41421 PyObject *resultobj;
41422 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41423 int arg2 = (int) wxHORIZONTAL ;
41424 wxStaticBoxSizer *result;
41425 PyObject * obj0 = 0 ;
41426 PyObject * obj1 = 0 ;
41427 char *kwnames[] = {
41428 (char *) "box",(char *) "orient", NULL
41429 };
41430
41431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41433 if (SWIG_arg_fail(1)) SWIG_fail;
41434 if (obj1) {
41435 {
41436 arg2 = (int)(SWIG_As_int(obj1));
41437 if (SWIG_arg_fail(2)) SWIG_fail;
41438 }
41439 }
41440 {
41441 PyThreadState* __tstate = wxPyBeginAllowThreads();
41442 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41443
41444 wxPyEndAllowThreads(__tstate);
41445 if (PyErr_Occurred()) SWIG_fail;
41446 }
41447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41448 return resultobj;
41449 fail:
41450 return NULL;
41451 }
41452
41453
41454 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41455 PyObject *resultobj;
41456 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41457 wxStaticBox *result;
41458 PyObject * obj0 = 0 ;
41459 char *kwnames[] = {
41460 (char *) "self", NULL
41461 };
41462
41463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41465 if (SWIG_arg_fail(1)) SWIG_fail;
41466 {
41467 PyThreadState* __tstate = wxPyBeginAllowThreads();
41468 result = (wxStaticBox *)(arg1)->GetStaticBox();
41469
41470 wxPyEndAllowThreads(__tstate);
41471 if (PyErr_Occurred()) SWIG_fail;
41472 }
41473 {
41474 resultobj = wxPyMake_wxObject(result, 0);
41475 }
41476 return resultobj;
41477 fail:
41478 return NULL;
41479 }
41480
41481
41482 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41483 PyObject *obj;
41484 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41485 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41486 Py_INCREF(obj);
41487 return Py_BuildValue((char *)"");
41488 }
41489 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41490 PyObject *resultobj;
41491 int arg1 = (int) 1 ;
41492 int arg2 = (int) 0 ;
41493 int arg3 = (int) 0 ;
41494 int arg4 = (int) 0 ;
41495 wxGridSizer *result;
41496 PyObject * obj0 = 0 ;
41497 PyObject * obj1 = 0 ;
41498 PyObject * obj2 = 0 ;
41499 PyObject * obj3 = 0 ;
41500 char *kwnames[] = {
41501 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41502 };
41503
41504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41505 if (obj0) {
41506 {
41507 arg1 = (int)(SWIG_As_int(obj0));
41508 if (SWIG_arg_fail(1)) SWIG_fail;
41509 }
41510 }
41511 if (obj1) {
41512 {
41513 arg2 = (int)(SWIG_As_int(obj1));
41514 if (SWIG_arg_fail(2)) SWIG_fail;
41515 }
41516 }
41517 if (obj2) {
41518 {
41519 arg3 = (int)(SWIG_As_int(obj2));
41520 if (SWIG_arg_fail(3)) SWIG_fail;
41521 }
41522 }
41523 if (obj3) {
41524 {
41525 arg4 = (int)(SWIG_As_int(obj3));
41526 if (SWIG_arg_fail(4)) SWIG_fail;
41527 }
41528 }
41529 {
41530 PyThreadState* __tstate = wxPyBeginAllowThreads();
41531 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41532
41533 wxPyEndAllowThreads(__tstate);
41534 if (PyErr_Occurred()) SWIG_fail;
41535 }
41536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41537 return resultobj;
41538 fail:
41539 return NULL;
41540 }
41541
41542
41543 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41544 PyObject *resultobj;
41545 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41546 int arg2 ;
41547 PyObject * obj0 = 0 ;
41548 PyObject * obj1 = 0 ;
41549 char *kwnames[] = {
41550 (char *) "self",(char *) "cols", NULL
41551 };
41552
41553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41555 if (SWIG_arg_fail(1)) SWIG_fail;
41556 {
41557 arg2 = (int)(SWIG_As_int(obj1));
41558 if (SWIG_arg_fail(2)) SWIG_fail;
41559 }
41560 {
41561 PyThreadState* __tstate = wxPyBeginAllowThreads();
41562 (arg1)->SetCols(arg2);
41563
41564 wxPyEndAllowThreads(__tstate);
41565 if (PyErr_Occurred()) SWIG_fail;
41566 }
41567 Py_INCREF(Py_None); resultobj = Py_None;
41568 return resultobj;
41569 fail:
41570 return NULL;
41571 }
41572
41573
41574 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41575 PyObject *resultobj;
41576 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41577 int arg2 ;
41578 PyObject * obj0 = 0 ;
41579 PyObject * obj1 = 0 ;
41580 char *kwnames[] = {
41581 (char *) "self",(char *) "rows", NULL
41582 };
41583
41584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41586 if (SWIG_arg_fail(1)) SWIG_fail;
41587 {
41588 arg2 = (int)(SWIG_As_int(obj1));
41589 if (SWIG_arg_fail(2)) SWIG_fail;
41590 }
41591 {
41592 PyThreadState* __tstate = wxPyBeginAllowThreads();
41593 (arg1)->SetRows(arg2);
41594
41595 wxPyEndAllowThreads(__tstate);
41596 if (PyErr_Occurred()) SWIG_fail;
41597 }
41598 Py_INCREF(Py_None); resultobj = Py_None;
41599 return resultobj;
41600 fail:
41601 return NULL;
41602 }
41603
41604
41605 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41606 PyObject *resultobj;
41607 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41608 int arg2 ;
41609 PyObject * obj0 = 0 ;
41610 PyObject * obj1 = 0 ;
41611 char *kwnames[] = {
41612 (char *) "self",(char *) "gap", NULL
41613 };
41614
41615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41617 if (SWIG_arg_fail(1)) SWIG_fail;
41618 {
41619 arg2 = (int)(SWIG_As_int(obj1));
41620 if (SWIG_arg_fail(2)) SWIG_fail;
41621 }
41622 {
41623 PyThreadState* __tstate = wxPyBeginAllowThreads();
41624 (arg1)->SetVGap(arg2);
41625
41626 wxPyEndAllowThreads(__tstate);
41627 if (PyErr_Occurred()) SWIG_fail;
41628 }
41629 Py_INCREF(Py_None); resultobj = Py_None;
41630 return resultobj;
41631 fail:
41632 return NULL;
41633 }
41634
41635
41636 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41637 PyObject *resultobj;
41638 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41639 int arg2 ;
41640 PyObject * obj0 = 0 ;
41641 PyObject * obj1 = 0 ;
41642 char *kwnames[] = {
41643 (char *) "self",(char *) "gap", NULL
41644 };
41645
41646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41648 if (SWIG_arg_fail(1)) SWIG_fail;
41649 {
41650 arg2 = (int)(SWIG_As_int(obj1));
41651 if (SWIG_arg_fail(2)) SWIG_fail;
41652 }
41653 {
41654 PyThreadState* __tstate = wxPyBeginAllowThreads();
41655 (arg1)->SetHGap(arg2);
41656
41657 wxPyEndAllowThreads(__tstate);
41658 if (PyErr_Occurred()) SWIG_fail;
41659 }
41660 Py_INCREF(Py_None); resultobj = Py_None;
41661 return resultobj;
41662 fail:
41663 return NULL;
41664 }
41665
41666
41667 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41668 PyObject *resultobj;
41669 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41670 int result;
41671 PyObject * obj0 = 0 ;
41672 char *kwnames[] = {
41673 (char *) "self", NULL
41674 };
41675
41676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41678 if (SWIG_arg_fail(1)) SWIG_fail;
41679 {
41680 PyThreadState* __tstate = wxPyBeginAllowThreads();
41681 result = (int)(arg1)->GetCols();
41682
41683 wxPyEndAllowThreads(__tstate);
41684 if (PyErr_Occurred()) SWIG_fail;
41685 }
41686 {
41687 resultobj = SWIG_From_int((int)(result));
41688 }
41689 return resultobj;
41690 fail:
41691 return NULL;
41692 }
41693
41694
41695 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41696 PyObject *resultobj;
41697 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41698 int result;
41699 PyObject * obj0 = 0 ;
41700 char *kwnames[] = {
41701 (char *) "self", NULL
41702 };
41703
41704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41706 if (SWIG_arg_fail(1)) SWIG_fail;
41707 {
41708 PyThreadState* __tstate = wxPyBeginAllowThreads();
41709 result = (int)(arg1)->GetRows();
41710
41711 wxPyEndAllowThreads(__tstate);
41712 if (PyErr_Occurred()) SWIG_fail;
41713 }
41714 {
41715 resultobj = SWIG_From_int((int)(result));
41716 }
41717 return resultobj;
41718 fail:
41719 return NULL;
41720 }
41721
41722
41723 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41724 PyObject *resultobj;
41725 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41726 int result;
41727 PyObject * obj0 = 0 ;
41728 char *kwnames[] = {
41729 (char *) "self", NULL
41730 };
41731
41732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41734 if (SWIG_arg_fail(1)) SWIG_fail;
41735 {
41736 PyThreadState* __tstate = wxPyBeginAllowThreads();
41737 result = (int)(arg1)->GetVGap();
41738
41739 wxPyEndAllowThreads(__tstate);
41740 if (PyErr_Occurred()) SWIG_fail;
41741 }
41742 {
41743 resultobj = SWIG_From_int((int)(result));
41744 }
41745 return resultobj;
41746 fail:
41747 return NULL;
41748 }
41749
41750
41751 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41752 PyObject *resultobj;
41753 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41754 int result;
41755 PyObject * obj0 = 0 ;
41756 char *kwnames[] = {
41757 (char *) "self", NULL
41758 };
41759
41760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41762 if (SWIG_arg_fail(1)) SWIG_fail;
41763 {
41764 PyThreadState* __tstate = wxPyBeginAllowThreads();
41765 result = (int)(arg1)->GetHGap();
41766
41767 wxPyEndAllowThreads(__tstate);
41768 if (PyErr_Occurred()) SWIG_fail;
41769 }
41770 {
41771 resultobj = SWIG_From_int((int)(result));
41772 }
41773 return resultobj;
41774 fail:
41775 return NULL;
41776 }
41777
41778
41779 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41780 PyObject *obj;
41781 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41782 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41783 Py_INCREF(obj);
41784 return Py_BuildValue((char *)"");
41785 }
41786 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41787 PyObject *resultobj;
41788 int arg1 = (int) 1 ;
41789 int arg2 = (int) 0 ;
41790 int arg3 = (int) 0 ;
41791 int arg4 = (int) 0 ;
41792 wxFlexGridSizer *result;
41793 PyObject * obj0 = 0 ;
41794 PyObject * obj1 = 0 ;
41795 PyObject * obj2 = 0 ;
41796 PyObject * obj3 = 0 ;
41797 char *kwnames[] = {
41798 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41799 };
41800
41801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41802 if (obj0) {
41803 {
41804 arg1 = (int)(SWIG_As_int(obj0));
41805 if (SWIG_arg_fail(1)) SWIG_fail;
41806 }
41807 }
41808 if (obj1) {
41809 {
41810 arg2 = (int)(SWIG_As_int(obj1));
41811 if (SWIG_arg_fail(2)) SWIG_fail;
41812 }
41813 }
41814 if (obj2) {
41815 {
41816 arg3 = (int)(SWIG_As_int(obj2));
41817 if (SWIG_arg_fail(3)) SWIG_fail;
41818 }
41819 }
41820 if (obj3) {
41821 {
41822 arg4 = (int)(SWIG_As_int(obj3));
41823 if (SWIG_arg_fail(4)) SWIG_fail;
41824 }
41825 }
41826 {
41827 PyThreadState* __tstate = wxPyBeginAllowThreads();
41828 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41829
41830 wxPyEndAllowThreads(__tstate);
41831 if (PyErr_Occurred()) SWIG_fail;
41832 }
41833 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41834 return resultobj;
41835 fail:
41836 return NULL;
41837 }
41838
41839
41840 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41841 PyObject *resultobj;
41842 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41843 size_t arg2 ;
41844 int arg3 = (int) 0 ;
41845 PyObject * obj0 = 0 ;
41846 PyObject * obj1 = 0 ;
41847 PyObject * obj2 = 0 ;
41848 char *kwnames[] = {
41849 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41850 };
41851
41852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41854 if (SWIG_arg_fail(1)) SWIG_fail;
41855 {
41856 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41857 if (SWIG_arg_fail(2)) SWIG_fail;
41858 }
41859 if (obj2) {
41860 {
41861 arg3 = (int)(SWIG_As_int(obj2));
41862 if (SWIG_arg_fail(3)) SWIG_fail;
41863 }
41864 }
41865 {
41866 PyThreadState* __tstate = wxPyBeginAllowThreads();
41867 (arg1)->AddGrowableRow(arg2,arg3);
41868
41869 wxPyEndAllowThreads(__tstate);
41870 if (PyErr_Occurred()) SWIG_fail;
41871 }
41872 Py_INCREF(Py_None); resultobj = Py_None;
41873 return resultobj;
41874 fail:
41875 return NULL;
41876 }
41877
41878
41879 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41880 PyObject *resultobj;
41881 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41882 size_t arg2 ;
41883 PyObject * obj0 = 0 ;
41884 PyObject * obj1 = 0 ;
41885 char *kwnames[] = {
41886 (char *) "self",(char *) "idx", NULL
41887 };
41888
41889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41891 if (SWIG_arg_fail(1)) SWIG_fail;
41892 {
41893 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41894 if (SWIG_arg_fail(2)) SWIG_fail;
41895 }
41896 {
41897 PyThreadState* __tstate = wxPyBeginAllowThreads();
41898 (arg1)->RemoveGrowableRow(arg2);
41899
41900 wxPyEndAllowThreads(__tstate);
41901 if (PyErr_Occurred()) SWIG_fail;
41902 }
41903 Py_INCREF(Py_None); resultobj = Py_None;
41904 return resultobj;
41905 fail:
41906 return NULL;
41907 }
41908
41909
41910 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41911 PyObject *resultobj;
41912 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41913 size_t arg2 ;
41914 int arg3 = (int) 0 ;
41915 PyObject * obj0 = 0 ;
41916 PyObject * obj1 = 0 ;
41917 PyObject * obj2 = 0 ;
41918 char *kwnames[] = {
41919 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41920 };
41921
41922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41924 if (SWIG_arg_fail(1)) SWIG_fail;
41925 {
41926 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41927 if (SWIG_arg_fail(2)) SWIG_fail;
41928 }
41929 if (obj2) {
41930 {
41931 arg3 = (int)(SWIG_As_int(obj2));
41932 if (SWIG_arg_fail(3)) SWIG_fail;
41933 }
41934 }
41935 {
41936 PyThreadState* __tstate = wxPyBeginAllowThreads();
41937 (arg1)->AddGrowableCol(arg2,arg3);
41938
41939 wxPyEndAllowThreads(__tstate);
41940 if (PyErr_Occurred()) SWIG_fail;
41941 }
41942 Py_INCREF(Py_None); resultobj = Py_None;
41943 return resultobj;
41944 fail:
41945 return NULL;
41946 }
41947
41948
41949 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41950 PyObject *resultobj;
41951 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41952 size_t arg2 ;
41953 PyObject * obj0 = 0 ;
41954 PyObject * obj1 = 0 ;
41955 char *kwnames[] = {
41956 (char *) "self",(char *) "idx", NULL
41957 };
41958
41959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41961 if (SWIG_arg_fail(1)) SWIG_fail;
41962 {
41963 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41964 if (SWIG_arg_fail(2)) SWIG_fail;
41965 }
41966 {
41967 PyThreadState* __tstate = wxPyBeginAllowThreads();
41968 (arg1)->RemoveGrowableCol(arg2);
41969
41970 wxPyEndAllowThreads(__tstate);
41971 if (PyErr_Occurred()) SWIG_fail;
41972 }
41973 Py_INCREF(Py_None); resultobj = Py_None;
41974 return resultobj;
41975 fail:
41976 return NULL;
41977 }
41978
41979
41980 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41981 PyObject *resultobj;
41982 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41983 int arg2 ;
41984 PyObject * obj0 = 0 ;
41985 PyObject * obj1 = 0 ;
41986 char *kwnames[] = {
41987 (char *) "self",(char *) "direction", NULL
41988 };
41989
41990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41992 if (SWIG_arg_fail(1)) SWIG_fail;
41993 {
41994 arg2 = (int)(SWIG_As_int(obj1));
41995 if (SWIG_arg_fail(2)) SWIG_fail;
41996 }
41997 {
41998 PyThreadState* __tstate = wxPyBeginAllowThreads();
41999 (arg1)->SetFlexibleDirection(arg2);
42000
42001 wxPyEndAllowThreads(__tstate);
42002 if (PyErr_Occurred()) SWIG_fail;
42003 }
42004 Py_INCREF(Py_None); resultobj = Py_None;
42005 return resultobj;
42006 fail:
42007 return NULL;
42008 }
42009
42010
42011 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42012 PyObject *resultobj;
42013 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42014 int result;
42015 PyObject * obj0 = 0 ;
42016 char *kwnames[] = {
42017 (char *) "self", NULL
42018 };
42019
42020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
42021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42022 if (SWIG_arg_fail(1)) SWIG_fail;
42023 {
42024 PyThreadState* __tstate = wxPyBeginAllowThreads();
42025 result = (int)(arg1)->GetFlexibleDirection();
42026
42027 wxPyEndAllowThreads(__tstate);
42028 if (PyErr_Occurred()) SWIG_fail;
42029 }
42030 {
42031 resultobj = SWIG_From_int((int)(result));
42032 }
42033 return resultobj;
42034 fail:
42035 return NULL;
42036 }
42037
42038
42039 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42040 PyObject *resultobj;
42041 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42042 wxFlexSizerGrowMode arg2 ;
42043 PyObject * obj0 = 0 ;
42044 PyObject * obj1 = 0 ;
42045 char *kwnames[] = {
42046 (char *) "self",(char *) "mode", NULL
42047 };
42048
42049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
42050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42051 if (SWIG_arg_fail(1)) SWIG_fail;
42052 {
42053 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
42054 if (SWIG_arg_fail(2)) SWIG_fail;
42055 }
42056 {
42057 PyThreadState* __tstate = wxPyBeginAllowThreads();
42058 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
42059
42060 wxPyEndAllowThreads(__tstate);
42061 if (PyErr_Occurred()) SWIG_fail;
42062 }
42063 Py_INCREF(Py_None); resultobj = Py_None;
42064 return resultobj;
42065 fail:
42066 return NULL;
42067 }
42068
42069
42070 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42071 PyObject *resultobj;
42072 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42073 wxFlexSizerGrowMode result;
42074 PyObject * obj0 = 0 ;
42075 char *kwnames[] = {
42076 (char *) "self", NULL
42077 };
42078
42079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
42080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42081 if (SWIG_arg_fail(1)) SWIG_fail;
42082 {
42083 PyThreadState* __tstate = wxPyBeginAllowThreads();
42084 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
42085
42086 wxPyEndAllowThreads(__tstate);
42087 if (PyErr_Occurred()) SWIG_fail;
42088 }
42089 resultobj = SWIG_From_int((result));
42090 return resultobj;
42091 fail:
42092 return NULL;
42093 }
42094
42095
42096 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
42097 PyObject *resultobj;
42098 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42099 wxArrayInt *result;
42100 PyObject * obj0 = 0 ;
42101 char *kwnames[] = {
42102 (char *) "self", NULL
42103 };
42104
42105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42107 if (SWIG_arg_fail(1)) SWIG_fail;
42108 {
42109 PyThreadState* __tstate = wxPyBeginAllowThreads();
42110 {
42111 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42112 result = (wxArrayInt *) &_result_ref;
42113 }
42114
42115 wxPyEndAllowThreads(__tstate);
42116 if (PyErr_Occurred()) SWIG_fail;
42117 }
42118 {
42119 resultobj = PyList_New(0);
42120 size_t idx;
42121 for (idx = 0; idx < result->GetCount(); idx += 1) {
42122 PyObject* val = PyInt_FromLong( result->Item(idx) );
42123 PyList_Append(resultobj, val);
42124 Py_DECREF(val);
42125 }
42126 }
42127 return resultobj;
42128 fail:
42129 return NULL;
42130 }
42131
42132
42133 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42134 PyObject *resultobj;
42135 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42136 wxArrayInt *result;
42137 PyObject * obj0 = 0 ;
42138 char *kwnames[] = {
42139 (char *) "self", NULL
42140 };
42141
42142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42144 if (SWIG_arg_fail(1)) SWIG_fail;
42145 {
42146 PyThreadState* __tstate = wxPyBeginAllowThreads();
42147 {
42148 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42149 result = (wxArrayInt *) &_result_ref;
42150 }
42151
42152 wxPyEndAllowThreads(__tstate);
42153 if (PyErr_Occurred()) SWIG_fail;
42154 }
42155 {
42156 resultobj = PyList_New(0);
42157 size_t idx;
42158 for (idx = 0; idx < result->GetCount(); idx += 1) {
42159 PyObject* val = PyInt_FromLong( result->Item(idx) );
42160 PyList_Append(resultobj, val);
42161 Py_DECREF(val);
42162 }
42163 }
42164 return resultobj;
42165 fail:
42166 return NULL;
42167 }
42168
42169
42170 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42171 PyObject *obj;
42172 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42173 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42174 Py_INCREF(obj);
42175 return Py_BuildValue((char *)"");
42176 }
42177 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42178 PyObject *resultobj;
42179 wxStdDialogButtonSizer *result;
42180 char *kwnames[] = {
42181 NULL
42182 };
42183
42184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42185 {
42186 PyThreadState* __tstate = wxPyBeginAllowThreads();
42187 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42188
42189 wxPyEndAllowThreads(__tstate);
42190 if (PyErr_Occurred()) SWIG_fail;
42191 }
42192 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42193 return resultobj;
42194 fail:
42195 return NULL;
42196 }
42197
42198
42199 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42200 PyObject *resultobj;
42201 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42202 wxButton *arg2 = (wxButton *) 0 ;
42203 PyObject * obj0 = 0 ;
42204 PyObject * obj1 = 0 ;
42205 char *kwnames[] = {
42206 (char *) "self",(char *) "button", NULL
42207 };
42208
42209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42211 if (SWIG_arg_fail(1)) SWIG_fail;
42212 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42213 if (SWIG_arg_fail(2)) SWIG_fail;
42214 {
42215 PyThreadState* __tstate = wxPyBeginAllowThreads();
42216 (arg1)->AddButton(arg2);
42217
42218 wxPyEndAllowThreads(__tstate);
42219 if (PyErr_Occurred()) SWIG_fail;
42220 }
42221 Py_INCREF(Py_None); resultobj = Py_None;
42222 return resultobj;
42223 fail:
42224 return NULL;
42225 }
42226
42227
42228 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42229 PyObject *resultobj;
42230 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42231 PyObject * obj0 = 0 ;
42232 char *kwnames[] = {
42233 (char *) "self", NULL
42234 };
42235
42236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42238 if (SWIG_arg_fail(1)) SWIG_fail;
42239 {
42240 PyThreadState* __tstate = wxPyBeginAllowThreads();
42241 (arg1)->Realize();
42242
42243 wxPyEndAllowThreads(__tstate);
42244 if (PyErr_Occurred()) SWIG_fail;
42245 }
42246 Py_INCREF(Py_None); resultobj = Py_None;
42247 return resultobj;
42248 fail:
42249 return NULL;
42250 }
42251
42252
42253 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42254 PyObject *resultobj;
42255 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42256 wxButton *arg2 = (wxButton *) 0 ;
42257 PyObject * obj0 = 0 ;
42258 PyObject * obj1 = 0 ;
42259 char *kwnames[] = {
42260 (char *) "self",(char *) "button", NULL
42261 };
42262
42263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42265 if (SWIG_arg_fail(1)) SWIG_fail;
42266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42267 if (SWIG_arg_fail(2)) SWIG_fail;
42268 {
42269 PyThreadState* __tstate = wxPyBeginAllowThreads();
42270 (arg1)->SetAffirmativeButton(arg2);
42271
42272 wxPyEndAllowThreads(__tstate);
42273 if (PyErr_Occurred()) SWIG_fail;
42274 }
42275 Py_INCREF(Py_None); resultobj = Py_None;
42276 return resultobj;
42277 fail:
42278 return NULL;
42279 }
42280
42281
42282 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42283 PyObject *resultobj;
42284 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42285 wxButton *arg2 = (wxButton *) 0 ;
42286 PyObject * obj0 = 0 ;
42287 PyObject * obj1 = 0 ;
42288 char *kwnames[] = {
42289 (char *) "self",(char *) "button", NULL
42290 };
42291
42292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42294 if (SWIG_arg_fail(1)) SWIG_fail;
42295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42296 if (SWIG_arg_fail(2)) SWIG_fail;
42297 {
42298 PyThreadState* __tstate = wxPyBeginAllowThreads();
42299 (arg1)->SetNegativeButton(arg2);
42300
42301 wxPyEndAllowThreads(__tstate);
42302 if (PyErr_Occurred()) SWIG_fail;
42303 }
42304 Py_INCREF(Py_None); resultobj = Py_None;
42305 return resultobj;
42306 fail:
42307 return NULL;
42308 }
42309
42310
42311 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42312 PyObject *resultobj;
42313 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42314 wxButton *arg2 = (wxButton *) 0 ;
42315 PyObject * obj0 = 0 ;
42316 PyObject * obj1 = 0 ;
42317 char *kwnames[] = {
42318 (char *) "self",(char *) "button", NULL
42319 };
42320
42321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42323 if (SWIG_arg_fail(1)) SWIG_fail;
42324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42325 if (SWIG_arg_fail(2)) SWIG_fail;
42326 {
42327 PyThreadState* __tstate = wxPyBeginAllowThreads();
42328 (arg1)->SetCancelButton(arg2);
42329
42330 wxPyEndAllowThreads(__tstate);
42331 if (PyErr_Occurred()) SWIG_fail;
42332 }
42333 Py_INCREF(Py_None); resultobj = Py_None;
42334 return resultobj;
42335 fail:
42336 return NULL;
42337 }
42338
42339
42340 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42341 PyObject *resultobj;
42342 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42343 wxButton *result;
42344 PyObject * obj0 = 0 ;
42345 char *kwnames[] = {
42346 (char *) "self", NULL
42347 };
42348
42349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42351 if (SWIG_arg_fail(1)) SWIG_fail;
42352 {
42353 PyThreadState* __tstate = wxPyBeginAllowThreads();
42354 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42355
42356 wxPyEndAllowThreads(__tstate);
42357 if (PyErr_Occurred()) SWIG_fail;
42358 }
42359 {
42360 resultobj = wxPyMake_wxObject(result, 0);
42361 }
42362 return resultobj;
42363 fail:
42364 return NULL;
42365 }
42366
42367
42368 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42369 PyObject *resultobj;
42370 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42371 wxButton *result;
42372 PyObject * obj0 = 0 ;
42373 char *kwnames[] = {
42374 (char *) "self", NULL
42375 };
42376
42377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42379 if (SWIG_arg_fail(1)) SWIG_fail;
42380 {
42381 PyThreadState* __tstate = wxPyBeginAllowThreads();
42382 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42383
42384 wxPyEndAllowThreads(__tstate);
42385 if (PyErr_Occurred()) SWIG_fail;
42386 }
42387 {
42388 resultobj = wxPyMake_wxObject(result, 0);
42389 }
42390 return resultobj;
42391 fail:
42392 return NULL;
42393 }
42394
42395
42396 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42397 PyObject *resultobj;
42398 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42399 wxButton *result;
42400 PyObject * obj0 = 0 ;
42401 char *kwnames[] = {
42402 (char *) "self", NULL
42403 };
42404
42405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42407 if (SWIG_arg_fail(1)) SWIG_fail;
42408 {
42409 PyThreadState* __tstate = wxPyBeginAllowThreads();
42410 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42411
42412 wxPyEndAllowThreads(__tstate);
42413 if (PyErr_Occurred()) SWIG_fail;
42414 }
42415 {
42416 resultobj = wxPyMake_wxObject(result, 0);
42417 }
42418 return resultobj;
42419 fail:
42420 return NULL;
42421 }
42422
42423
42424 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42425 PyObject *resultobj;
42426 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42427 wxButton *result;
42428 PyObject * obj0 = 0 ;
42429 char *kwnames[] = {
42430 (char *) "self", NULL
42431 };
42432
42433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42435 if (SWIG_arg_fail(1)) SWIG_fail;
42436 {
42437 PyThreadState* __tstate = wxPyBeginAllowThreads();
42438 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42439
42440 wxPyEndAllowThreads(__tstate);
42441 if (PyErr_Occurred()) SWIG_fail;
42442 }
42443 {
42444 resultobj = wxPyMake_wxObject(result, 0);
42445 }
42446 return resultobj;
42447 fail:
42448 return NULL;
42449 }
42450
42451
42452 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42453 PyObject *resultobj;
42454 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42455 wxButton *result;
42456 PyObject * obj0 = 0 ;
42457 char *kwnames[] = {
42458 (char *) "self", NULL
42459 };
42460
42461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42463 if (SWIG_arg_fail(1)) SWIG_fail;
42464 {
42465 PyThreadState* __tstate = wxPyBeginAllowThreads();
42466 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42467
42468 wxPyEndAllowThreads(__tstate);
42469 if (PyErr_Occurred()) SWIG_fail;
42470 }
42471 {
42472 resultobj = wxPyMake_wxObject(result, 0);
42473 }
42474 return resultobj;
42475 fail:
42476 return NULL;
42477 }
42478
42479
42480 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42481 PyObject *obj;
42482 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42483 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42484 Py_INCREF(obj);
42485 return Py_BuildValue((char *)"");
42486 }
42487 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42488 PyObject *resultobj;
42489 int arg1 = (int) 0 ;
42490 int arg2 = (int) 0 ;
42491 wxGBPosition *result;
42492 PyObject * obj0 = 0 ;
42493 PyObject * obj1 = 0 ;
42494 char *kwnames[] = {
42495 (char *) "row",(char *) "col", NULL
42496 };
42497
42498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42499 if (obj0) {
42500 {
42501 arg1 = (int)(SWIG_As_int(obj0));
42502 if (SWIG_arg_fail(1)) SWIG_fail;
42503 }
42504 }
42505 if (obj1) {
42506 {
42507 arg2 = (int)(SWIG_As_int(obj1));
42508 if (SWIG_arg_fail(2)) SWIG_fail;
42509 }
42510 }
42511 {
42512 PyThreadState* __tstate = wxPyBeginAllowThreads();
42513 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42514
42515 wxPyEndAllowThreads(__tstate);
42516 if (PyErr_Occurred()) SWIG_fail;
42517 }
42518 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42519 return resultobj;
42520 fail:
42521 return NULL;
42522 }
42523
42524
42525 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42526 PyObject *resultobj;
42527 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42528 int result;
42529 PyObject * obj0 = 0 ;
42530 char *kwnames[] = {
42531 (char *) "self", NULL
42532 };
42533
42534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42536 if (SWIG_arg_fail(1)) SWIG_fail;
42537 {
42538 PyThreadState* __tstate = wxPyBeginAllowThreads();
42539 result = (int)((wxGBPosition const *)arg1)->GetRow();
42540
42541 wxPyEndAllowThreads(__tstate);
42542 if (PyErr_Occurred()) SWIG_fail;
42543 }
42544 {
42545 resultobj = SWIG_From_int((int)(result));
42546 }
42547 return resultobj;
42548 fail:
42549 return NULL;
42550 }
42551
42552
42553 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42554 PyObject *resultobj;
42555 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42556 int result;
42557 PyObject * obj0 = 0 ;
42558 char *kwnames[] = {
42559 (char *) "self", NULL
42560 };
42561
42562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42564 if (SWIG_arg_fail(1)) SWIG_fail;
42565 {
42566 PyThreadState* __tstate = wxPyBeginAllowThreads();
42567 result = (int)((wxGBPosition const *)arg1)->GetCol();
42568
42569 wxPyEndAllowThreads(__tstate);
42570 if (PyErr_Occurred()) SWIG_fail;
42571 }
42572 {
42573 resultobj = SWIG_From_int((int)(result));
42574 }
42575 return resultobj;
42576 fail:
42577 return NULL;
42578 }
42579
42580
42581 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42582 PyObject *resultobj;
42583 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42584 int arg2 ;
42585 PyObject * obj0 = 0 ;
42586 PyObject * obj1 = 0 ;
42587 char *kwnames[] = {
42588 (char *) "self",(char *) "row", NULL
42589 };
42590
42591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42593 if (SWIG_arg_fail(1)) SWIG_fail;
42594 {
42595 arg2 = (int)(SWIG_As_int(obj1));
42596 if (SWIG_arg_fail(2)) SWIG_fail;
42597 }
42598 {
42599 PyThreadState* __tstate = wxPyBeginAllowThreads();
42600 (arg1)->SetRow(arg2);
42601
42602 wxPyEndAllowThreads(__tstate);
42603 if (PyErr_Occurred()) SWIG_fail;
42604 }
42605 Py_INCREF(Py_None); resultobj = Py_None;
42606 return resultobj;
42607 fail:
42608 return NULL;
42609 }
42610
42611
42612 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42613 PyObject *resultobj;
42614 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42615 int arg2 ;
42616 PyObject * obj0 = 0 ;
42617 PyObject * obj1 = 0 ;
42618 char *kwnames[] = {
42619 (char *) "self",(char *) "col", NULL
42620 };
42621
42622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42624 if (SWIG_arg_fail(1)) SWIG_fail;
42625 {
42626 arg2 = (int)(SWIG_As_int(obj1));
42627 if (SWIG_arg_fail(2)) SWIG_fail;
42628 }
42629 {
42630 PyThreadState* __tstate = wxPyBeginAllowThreads();
42631 (arg1)->SetCol(arg2);
42632
42633 wxPyEndAllowThreads(__tstate);
42634 if (PyErr_Occurred()) SWIG_fail;
42635 }
42636 Py_INCREF(Py_None); resultobj = Py_None;
42637 return resultobj;
42638 fail:
42639 return NULL;
42640 }
42641
42642
42643 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42644 PyObject *resultobj;
42645 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42646 wxGBPosition *arg2 = 0 ;
42647 bool result;
42648 wxGBPosition temp2 ;
42649 PyObject * obj0 = 0 ;
42650 PyObject * obj1 = 0 ;
42651 char *kwnames[] = {
42652 (char *) "self",(char *) "other", NULL
42653 };
42654
42655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42657 if (SWIG_arg_fail(1)) SWIG_fail;
42658 {
42659 arg2 = &temp2;
42660 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42661 }
42662 {
42663 PyThreadState* __tstate = wxPyBeginAllowThreads();
42664 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42665
42666 wxPyEndAllowThreads(__tstate);
42667 if (PyErr_Occurred()) SWIG_fail;
42668 }
42669 {
42670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42671 }
42672 return resultobj;
42673 fail:
42674 return NULL;
42675 }
42676
42677
42678 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42679 PyObject *resultobj;
42680 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42681 wxGBPosition *arg2 = 0 ;
42682 bool result;
42683 wxGBPosition temp2 ;
42684 PyObject * obj0 = 0 ;
42685 PyObject * obj1 = 0 ;
42686 char *kwnames[] = {
42687 (char *) "self",(char *) "other", NULL
42688 };
42689
42690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42692 if (SWIG_arg_fail(1)) SWIG_fail;
42693 {
42694 arg2 = &temp2;
42695 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42696 }
42697 {
42698 PyThreadState* __tstate = wxPyBeginAllowThreads();
42699 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42700
42701 wxPyEndAllowThreads(__tstate);
42702 if (PyErr_Occurred()) SWIG_fail;
42703 }
42704 {
42705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42706 }
42707 return resultobj;
42708 fail:
42709 return NULL;
42710 }
42711
42712
42713 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42714 PyObject *resultobj;
42715 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42716 int arg2 = (int) 0 ;
42717 int arg3 = (int) 0 ;
42718 PyObject * obj0 = 0 ;
42719 PyObject * obj1 = 0 ;
42720 PyObject * obj2 = 0 ;
42721 char *kwnames[] = {
42722 (char *) "self",(char *) "row",(char *) "col", NULL
42723 };
42724
42725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42727 if (SWIG_arg_fail(1)) SWIG_fail;
42728 if (obj1) {
42729 {
42730 arg2 = (int)(SWIG_As_int(obj1));
42731 if (SWIG_arg_fail(2)) SWIG_fail;
42732 }
42733 }
42734 if (obj2) {
42735 {
42736 arg3 = (int)(SWIG_As_int(obj2));
42737 if (SWIG_arg_fail(3)) SWIG_fail;
42738 }
42739 }
42740 {
42741 PyThreadState* __tstate = wxPyBeginAllowThreads();
42742 wxGBPosition_Set(arg1,arg2,arg3);
42743
42744 wxPyEndAllowThreads(__tstate);
42745 if (PyErr_Occurred()) SWIG_fail;
42746 }
42747 Py_INCREF(Py_None); resultobj = Py_None;
42748 return resultobj;
42749 fail:
42750 return NULL;
42751 }
42752
42753
42754 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42755 PyObject *resultobj;
42756 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42757 PyObject *result;
42758 PyObject * obj0 = 0 ;
42759 char *kwnames[] = {
42760 (char *) "self", NULL
42761 };
42762
42763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42765 if (SWIG_arg_fail(1)) SWIG_fail;
42766 {
42767 PyThreadState* __tstate = wxPyBeginAllowThreads();
42768 result = (PyObject *)wxGBPosition_Get(arg1);
42769
42770 wxPyEndAllowThreads(__tstate);
42771 if (PyErr_Occurred()) SWIG_fail;
42772 }
42773 resultobj = result;
42774 return resultobj;
42775 fail:
42776 return NULL;
42777 }
42778
42779
42780 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42781 PyObject *obj;
42782 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42783 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42784 Py_INCREF(obj);
42785 return Py_BuildValue((char *)"");
42786 }
42787 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42788 PyObject *resultobj;
42789 int arg1 = (int) 1 ;
42790 int arg2 = (int) 1 ;
42791 wxGBSpan *result;
42792 PyObject * obj0 = 0 ;
42793 PyObject * obj1 = 0 ;
42794 char *kwnames[] = {
42795 (char *) "rowspan",(char *) "colspan", NULL
42796 };
42797
42798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42799 if (obj0) {
42800 {
42801 arg1 = (int)(SWIG_As_int(obj0));
42802 if (SWIG_arg_fail(1)) SWIG_fail;
42803 }
42804 }
42805 if (obj1) {
42806 {
42807 arg2 = (int)(SWIG_As_int(obj1));
42808 if (SWIG_arg_fail(2)) SWIG_fail;
42809 }
42810 }
42811 {
42812 PyThreadState* __tstate = wxPyBeginAllowThreads();
42813 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42814
42815 wxPyEndAllowThreads(__tstate);
42816 if (PyErr_Occurred()) SWIG_fail;
42817 }
42818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42819 return resultobj;
42820 fail:
42821 return NULL;
42822 }
42823
42824
42825 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42826 PyObject *resultobj;
42827 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42828 int result;
42829 PyObject * obj0 = 0 ;
42830 char *kwnames[] = {
42831 (char *) "self", NULL
42832 };
42833
42834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42836 if (SWIG_arg_fail(1)) SWIG_fail;
42837 {
42838 PyThreadState* __tstate = wxPyBeginAllowThreads();
42839 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42840
42841 wxPyEndAllowThreads(__tstate);
42842 if (PyErr_Occurred()) SWIG_fail;
42843 }
42844 {
42845 resultobj = SWIG_From_int((int)(result));
42846 }
42847 return resultobj;
42848 fail:
42849 return NULL;
42850 }
42851
42852
42853 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42854 PyObject *resultobj;
42855 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42856 int result;
42857 PyObject * obj0 = 0 ;
42858 char *kwnames[] = {
42859 (char *) "self", NULL
42860 };
42861
42862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42864 if (SWIG_arg_fail(1)) SWIG_fail;
42865 {
42866 PyThreadState* __tstate = wxPyBeginAllowThreads();
42867 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42868
42869 wxPyEndAllowThreads(__tstate);
42870 if (PyErr_Occurred()) SWIG_fail;
42871 }
42872 {
42873 resultobj = SWIG_From_int((int)(result));
42874 }
42875 return resultobj;
42876 fail:
42877 return NULL;
42878 }
42879
42880
42881 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42882 PyObject *resultobj;
42883 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42884 int arg2 ;
42885 PyObject * obj0 = 0 ;
42886 PyObject * obj1 = 0 ;
42887 char *kwnames[] = {
42888 (char *) "self",(char *) "rowspan", NULL
42889 };
42890
42891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42893 if (SWIG_arg_fail(1)) SWIG_fail;
42894 {
42895 arg2 = (int)(SWIG_As_int(obj1));
42896 if (SWIG_arg_fail(2)) SWIG_fail;
42897 }
42898 {
42899 PyThreadState* __tstate = wxPyBeginAllowThreads();
42900 (arg1)->SetRowspan(arg2);
42901
42902 wxPyEndAllowThreads(__tstate);
42903 if (PyErr_Occurred()) SWIG_fail;
42904 }
42905 Py_INCREF(Py_None); resultobj = Py_None;
42906 return resultobj;
42907 fail:
42908 return NULL;
42909 }
42910
42911
42912 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42913 PyObject *resultobj;
42914 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42915 int arg2 ;
42916 PyObject * obj0 = 0 ;
42917 PyObject * obj1 = 0 ;
42918 char *kwnames[] = {
42919 (char *) "self",(char *) "colspan", NULL
42920 };
42921
42922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42924 if (SWIG_arg_fail(1)) SWIG_fail;
42925 {
42926 arg2 = (int)(SWIG_As_int(obj1));
42927 if (SWIG_arg_fail(2)) SWIG_fail;
42928 }
42929 {
42930 PyThreadState* __tstate = wxPyBeginAllowThreads();
42931 (arg1)->SetColspan(arg2);
42932
42933 wxPyEndAllowThreads(__tstate);
42934 if (PyErr_Occurred()) SWIG_fail;
42935 }
42936 Py_INCREF(Py_None); resultobj = Py_None;
42937 return resultobj;
42938 fail:
42939 return NULL;
42940 }
42941
42942
42943 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42944 PyObject *resultobj;
42945 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42946 wxGBSpan *arg2 = 0 ;
42947 bool result;
42948 wxGBSpan temp2 ;
42949 PyObject * obj0 = 0 ;
42950 PyObject * obj1 = 0 ;
42951 char *kwnames[] = {
42952 (char *) "self",(char *) "other", NULL
42953 };
42954
42955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42957 if (SWIG_arg_fail(1)) SWIG_fail;
42958 {
42959 arg2 = &temp2;
42960 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42961 }
42962 {
42963 PyThreadState* __tstate = wxPyBeginAllowThreads();
42964 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42965
42966 wxPyEndAllowThreads(__tstate);
42967 if (PyErr_Occurred()) SWIG_fail;
42968 }
42969 {
42970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42971 }
42972 return resultobj;
42973 fail:
42974 return NULL;
42975 }
42976
42977
42978 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42979 PyObject *resultobj;
42980 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42981 wxGBSpan *arg2 = 0 ;
42982 bool result;
42983 wxGBSpan temp2 ;
42984 PyObject * obj0 = 0 ;
42985 PyObject * obj1 = 0 ;
42986 char *kwnames[] = {
42987 (char *) "self",(char *) "other", NULL
42988 };
42989
42990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42992 if (SWIG_arg_fail(1)) SWIG_fail;
42993 {
42994 arg2 = &temp2;
42995 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42996 }
42997 {
42998 PyThreadState* __tstate = wxPyBeginAllowThreads();
42999 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
43000
43001 wxPyEndAllowThreads(__tstate);
43002 if (PyErr_Occurred()) SWIG_fail;
43003 }
43004 {
43005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43006 }
43007 return resultobj;
43008 fail:
43009 return NULL;
43010 }
43011
43012
43013 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43014 PyObject *resultobj;
43015 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43016 int arg2 = (int) 1 ;
43017 int arg3 = (int) 1 ;
43018 PyObject * obj0 = 0 ;
43019 PyObject * obj1 = 0 ;
43020 PyObject * obj2 = 0 ;
43021 char *kwnames[] = {
43022 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
43023 };
43024
43025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43027 if (SWIG_arg_fail(1)) SWIG_fail;
43028 if (obj1) {
43029 {
43030 arg2 = (int)(SWIG_As_int(obj1));
43031 if (SWIG_arg_fail(2)) SWIG_fail;
43032 }
43033 }
43034 if (obj2) {
43035 {
43036 arg3 = (int)(SWIG_As_int(obj2));
43037 if (SWIG_arg_fail(3)) SWIG_fail;
43038 }
43039 }
43040 {
43041 PyThreadState* __tstate = wxPyBeginAllowThreads();
43042 wxGBSpan_Set(arg1,arg2,arg3);
43043
43044 wxPyEndAllowThreads(__tstate);
43045 if (PyErr_Occurred()) SWIG_fail;
43046 }
43047 Py_INCREF(Py_None); resultobj = Py_None;
43048 return resultobj;
43049 fail:
43050 return NULL;
43051 }
43052
43053
43054 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43055 PyObject *resultobj;
43056 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43057 PyObject *result;
43058 PyObject * obj0 = 0 ;
43059 char *kwnames[] = {
43060 (char *) "self", NULL
43061 };
43062
43063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
43064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43065 if (SWIG_arg_fail(1)) SWIG_fail;
43066 {
43067 PyThreadState* __tstate = wxPyBeginAllowThreads();
43068 result = (PyObject *)wxGBSpan_Get(arg1);
43069
43070 wxPyEndAllowThreads(__tstate);
43071 if (PyErr_Occurred()) SWIG_fail;
43072 }
43073 resultobj = result;
43074 return resultobj;
43075 fail:
43076 return NULL;
43077 }
43078
43079
43080 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
43081 PyObject *obj;
43082 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43083 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
43084 Py_INCREF(obj);
43085 return Py_BuildValue((char *)"");
43086 }
43087 static int _wrap_DefaultSpan_set(PyObject *) {
43088 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
43089 return 1;
43090 }
43091
43092
43093 static PyObject *_wrap_DefaultSpan_get(void) {
43094 PyObject *pyobj;
43095
43096 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
43097 return pyobj;
43098 }
43099
43100
43101 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43102 PyObject *resultobj;
43103 wxGBSizerItem *result;
43104 char *kwnames[] = {
43105 NULL
43106 };
43107
43108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43109 {
43110 PyThreadState* __tstate = wxPyBeginAllowThreads();
43111 result = (wxGBSizerItem *)new wxGBSizerItem();
43112
43113 wxPyEndAllowThreads(__tstate);
43114 if (PyErr_Occurred()) SWIG_fail;
43115 }
43116 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43117 return resultobj;
43118 fail:
43119 return NULL;
43120 }
43121
43122
43123 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43124 PyObject *resultobj;
43125 wxWindow *arg1 = (wxWindow *) 0 ;
43126 wxGBPosition *arg2 = 0 ;
43127 wxGBSpan *arg3 = 0 ;
43128 int arg4 ;
43129 int arg5 ;
43130 PyObject *arg6 = (PyObject *) NULL ;
43131 wxGBSizerItem *result;
43132 wxGBPosition temp2 ;
43133 wxGBSpan temp3 ;
43134 PyObject * obj0 = 0 ;
43135 PyObject * obj1 = 0 ;
43136 PyObject * obj2 = 0 ;
43137 PyObject * obj3 = 0 ;
43138 PyObject * obj4 = 0 ;
43139 PyObject * obj5 = 0 ;
43140 char *kwnames[] = {
43141 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43142 };
43143
43144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43146 if (SWIG_arg_fail(1)) SWIG_fail;
43147 {
43148 arg2 = &temp2;
43149 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43150 }
43151 {
43152 arg3 = &temp3;
43153 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43154 }
43155 {
43156 arg4 = (int)(SWIG_As_int(obj3));
43157 if (SWIG_arg_fail(4)) SWIG_fail;
43158 }
43159 {
43160 arg5 = (int)(SWIG_As_int(obj4));
43161 if (SWIG_arg_fail(5)) SWIG_fail;
43162 }
43163 if (obj5) {
43164 arg6 = obj5;
43165 }
43166 {
43167 PyThreadState* __tstate = wxPyBeginAllowThreads();
43168 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43169
43170 wxPyEndAllowThreads(__tstate);
43171 if (PyErr_Occurred()) SWIG_fail;
43172 }
43173 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43174 return resultobj;
43175 fail:
43176 return NULL;
43177 }
43178
43179
43180 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43181 PyObject *resultobj;
43182 wxSizer *arg1 = (wxSizer *) 0 ;
43183 wxGBPosition *arg2 = 0 ;
43184 wxGBSpan *arg3 = 0 ;
43185 int arg4 ;
43186 int arg5 ;
43187 PyObject *arg6 = (PyObject *) NULL ;
43188 wxGBSizerItem *result;
43189 wxGBPosition temp2 ;
43190 wxGBSpan temp3 ;
43191 PyObject * obj0 = 0 ;
43192 PyObject * obj1 = 0 ;
43193 PyObject * obj2 = 0 ;
43194 PyObject * obj3 = 0 ;
43195 PyObject * obj4 = 0 ;
43196 PyObject * obj5 = 0 ;
43197 char *kwnames[] = {
43198 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43199 };
43200
43201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43203 if (SWIG_arg_fail(1)) SWIG_fail;
43204 {
43205 arg2 = &temp2;
43206 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43207 }
43208 {
43209 arg3 = &temp3;
43210 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43211 }
43212 {
43213 arg4 = (int)(SWIG_As_int(obj3));
43214 if (SWIG_arg_fail(4)) SWIG_fail;
43215 }
43216 {
43217 arg5 = (int)(SWIG_As_int(obj4));
43218 if (SWIG_arg_fail(5)) SWIG_fail;
43219 }
43220 if (obj5) {
43221 arg6 = obj5;
43222 }
43223 {
43224 PyThreadState* __tstate = wxPyBeginAllowThreads();
43225 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43226
43227 wxPyEndAllowThreads(__tstate);
43228 if (PyErr_Occurred()) SWIG_fail;
43229 }
43230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43231 return resultobj;
43232 fail:
43233 return NULL;
43234 }
43235
43236
43237 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43238 PyObject *resultobj;
43239 int arg1 ;
43240 int arg2 ;
43241 wxGBPosition *arg3 = 0 ;
43242 wxGBSpan *arg4 = 0 ;
43243 int arg5 ;
43244 int arg6 ;
43245 PyObject *arg7 = (PyObject *) NULL ;
43246 wxGBSizerItem *result;
43247 wxGBPosition temp3 ;
43248 wxGBSpan temp4 ;
43249 PyObject * obj0 = 0 ;
43250 PyObject * obj1 = 0 ;
43251 PyObject * obj2 = 0 ;
43252 PyObject * obj3 = 0 ;
43253 PyObject * obj4 = 0 ;
43254 PyObject * obj5 = 0 ;
43255 PyObject * obj6 = 0 ;
43256 char *kwnames[] = {
43257 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43258 };
43259
43260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43261 {
43262 arg1 = (int)(SWIG_As_int(obj0));
43263 if (SWIG_arg_fail(1)) SWIG_fail;
43264 }
43265 {
43266 arg2 = (int)(SWIG_As_int(obj1));
43267 if (SWIG_arg_fail(2)) SWIG_fail;
43268 }
43269 {
43270 arg3 = &temp3;
43271 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43272 }
43273 {
43274 arg4 = &temp4;
43275 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43276 }
43277 {
43278 arg5 = (int)(SWIG_As_int(obj4));
43279 if (SWIG_arg_fail(5)) SWIG_fail;
43280 }
43281 {
43282 arg6 = (int)(SWIG_As_int(obj5));
43283 if (SWIG_arg_fail(6)) SWIG_fail;
43284 }
43285 if (obj6) {
43286 arg7 = obj6;
43287 }
43288 {
43289 PyThreadState* __tstate = wxPyBeginAllowThreads();
43290 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43291
43292 wxPyEndAllowThreads(__tstate);
43293 if (PyErr_Occurred()) SWIG_fail;
43294 }
43295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43296 return resultobj;
43297 fail:
43298 return NULL;
43299 }
43300
43301
43302 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43303 PyObject *resultobj;
43304 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43305 wxGBPosition result;
43306 PyObject * obj0 = 0 ;
43307 char *kwnames[] = {
43308 (char *) "self", NULL
43309 };
43310
43311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43313 if (SWIG_arg_fail(1)) SWIG_fail;
43314 {
43315 PyThreadState* __tstate = wxPyBeginAllowThreads();
43316 result = ((wxGBSizerItem const *)arg1)->GetPos();
43317
43318 wxPyEndAllowThreads(__tstate);
43319 if (PyErr_Occurred()) SWIG_fail;
43320 }
43321 {
43322 wxGBPosition * resultptr;
43323 resultptr = new wxGBPosition((wxGBPosition &)(result));
43324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43325 }
43326 return resultobj;
43327 fail:
43328 return NULL;
43329 }
43330
43331
43332 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43333 PyObject *resultobj;
43334 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43335 wxGBSpan result;
43336 PyObject * obj0 = 0 ;
43337 char *kwnames[] = {
43338 (char *) "self", NULL
43339 };
43340
43341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43343 if (SWIG_arg_fail(1)) SWIG_fail;
43344 {
43345 PyThreadState* __tstate = wxPyBeginAllowThreads();
43346 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43347
43348 wxPyEndAllowThreads(__tstate);
43349 if (PyErr_Occurred()) SWIG_fail;
43350 }
43351 {
43352 wxGBSpan * resultptr;
43353 resultptr = new wxGBSpan((wxGBSpan &)(result));
43354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43355 }
43356 return resultobj;
43357 fail:
43358 return NULL;
43359 }
43360
43361
43362 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43363 PyObject *resultobj;
43364 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43365 wxGBPosition *arg2 = 0 ;
43366 bool result;
43367 wxGBPosition temp2 ;
43368 PyObject * obj0 = 0 ;
43369 PyObject * obj1 = 0 ;
43370 char *kwnames[] = {
43371 (char *) "self",(char *) "pos", NULL
43372 };
43373
43374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43376 if (SWIG_arg_fail(1)) SWIG_fail;
43377 {
43378 arg2 = &temp2;
43379 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43380 }
43381 {
43382 PyThreadState* __tstate = wxPyBeginAllowThreads();
43383 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43384
43385 wxPyEndAllowThreads(__tstate);
43386 if (PyErr_Occurred()) SWIG_fail;
43387 }
43388 {
43389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43390 }
43391 return resultobj;
43392 fail:
43393 return NULL;
43394 }
43395
43396
43397 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43398 PyObject *resultobj;
43399 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43400 wxGBSpan *arg2 = 0 ;
43401 bool result;
43402 wxGBSpan temp2 ;
43403 PyObject * obj0 = 0 ;
43404 PyObject * obj1 = 0 ;
43405 char *kwnames[] = {
43406 (char *) "self",(char *) "span", NULL
43407 };
43408
43409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43411 if (SWIG_arg_fail(1)) SWIG_fail;
43412 {
43413 arg2 = &temp2;
43414 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43415 }
43416 {
43417 PyThreadState* __tstate = wxPyBeginAllowThreads();
43418 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43419
43420 wxPyEndAllowThreads(__tstate);
43421 if (PyErr_Occurred()) SWIG_fail;
43422 }
43423 {
43424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43425 }
43426 return resultobj;
43427 fail:
43428 return NULL;
43429 }
43430
43431
43432 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43433 PyObject *resultobj;
43434 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43435 wxGBSizerItem *arg2 = 0 ;
43436 bool result;
43437 PyObject * obj0 = 0 ;
43438 PyObject * obj1 = 0 ;
43439 char *kwnames[] = {
43440 (char *) "self",(char *) "other", NULL
43441 };
43442
43443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43445 if (SWIG_arg_fail(1)) SWIG_fail;
43446 {
43447 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43448 if (SWIG_arg_fail(2)) SWIG_fail;
43449 if (arg2 == NULL) {
43450 SWIG_null_ref("wxGBSizerItem");
43451 }
43452 if (SWIG_arg_fail(2)) SWIG_fail;
43453 }
43454 {
43455 PyThreadState* __tstate = wxPyBeginAllowThreads();
43456 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43457
43458 wxPyEndAllowThreads(__tstate);
43459 if (PyErr_Occurred()) SWIG_fail;
43460 }
43461 {
43462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43463 }
43464 return resultobj;
43465 fail:
43466 return NULL;
43467 }
43468
43469
43470 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43471 PyObject *resultobj;
43472 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43473 wxGBPosition *arg2 = 0 ;
43474 wxGBSpan *arg3 = 0 ;
43475 bool result;
43476 wxGBPosition temp2 ;
43477 wxGBSpan temp3 ;
43478 PyObject * obj0 = 0 ;
43479 PyObject * obj1 = 0 ;
43480 PyObject * obj2 = 0 ;
43481 char *kwnames[] = {
43482 (char *) "self",(char *) "pos",(char *) "span", NULL
43483 };
43484
43485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43487 if (SWIG_arg_fail(1)) SWIG_fail;
43488 {
43489 arg2 = &temp2;
43490 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43491 }
43492 {
43493 arg3 = &temp3;
43494 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43495 }
43496 {
43497 PyThreadState* __tstate = wxPyBeginAllowThreads();
43498 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43499
43500 wxPyEndAllowThreads(__tstate);
43501 if (PyErr_Occurred()) SWIG_fail;
43502 }
43503 {
43504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43505 }
43506 return resultobj;
43507 fail:
43508 return NULL;
43509 }
43510
43511
43512 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43513 PyObject *resultobj;
43514 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43515 wxGBPosition result;
43516 PyObject * obj0 = 0 ;
43517 char *kwnames[] = {
43518 (char *) "self", NULL
43519 };
43520
43521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43523 if (SWIG_arg_fail(1)) SWIG_fail;
43524 {
43525 PyThreadState* __tstate = wxPyBeginAllowThreads();
43526 result = wxGBSizerItem_GetEndPos(arg1);
43527
43528 wxPyEndAllowThreads(__tstate);
43529 if (PyErr_Occurred()) SWIG_fail;
43530 }
43531 {
43532 wxGBPosition * resultptr;
43533 resultptr = new wxGBPosition((wxGBPosition &)(result));
43534 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43535 }
43536 return resultobj;
43537 fail:
43538 return NULL;
43539 }
43540
43541
43542 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43543 PyObject *resultobj;
43544 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43545 wxGridBagSizer *result;
43546 PyObject * obj0 = 0 ;
43547 char *kwnames[] = {
43548 (char *) "self", NULL
43549 };
43550
43551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43553 if (SWIG_arg_fail(1)) SWIG_fail;
43554 {
43555 PyThreadState* __tstate = wxPyBeginAllowThreads();
43556 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43557
43558 wxPyEndAllowThreads(__tstate);
43559 if (PyErr_Occurred()) SWIG_fail;
43560 }
43561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43562 return resultobj;
43563 fail:
43564 return NULL;
43565 }
43566
43567
43568 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43569 PyObject *resultobj;
43570 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43571 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43572 PyObject * obj0 = 0 ;
43573 PyObject * obj1 = 0 ;
43574 char *kwnames[] = {
43575 (char *) "self",(char *) "sizer", NULL
43576 };
43577
43578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43580 if (SWIG_arg_fail(1)) SWIG_fail;
43581 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43582 if (SWIG_arg_fail(2)) SWIG_fail;
43583 {
43584 PyThreadState* __tstate = wxPyBeginAllowThreads();
43585 (arg1)->SetGBSizer(arg2);
43586
43587 wxPyEndAllowThreads(__tstate);
43588 if (PyErr_Occurred()) SWIG_fail;
43589 }
43590 Py_INCREF(Py_None); resultobj = Py_None;
43591 return resultobj;
43592 fail:
43593 return NULL;
43594 }
43595
43596
43597 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43598 PyObject *obj;
43599 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43600 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43601 Py_INCREF(obj);
43602 return Py_BuildValue((char *)"");
43603 }
43604 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43605 PyObject *resultobj;
43606 int arg1 = (int) 0 ;
43607 int arg2 = (int) 0 ;
43608 wxGridBagSizer *result;
43609 PyObject * obj0 = 0 ;
43610 PyObject * obj1 = 0 ;
43611 char *kwnames[] = {
43612 (char *) "vgap",(char *) "hgap", NULL
43613 };
43614
43615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43616 if (obj0) {
43617 {
43618 arg1 = (int)(SWIG_As_int(obj0));
43619 if (SWIG_arg_fail(1)) SWIG_fail;
43620 }
43621 }
43622 if (obj1) {
43623 {
43624 arg2 = (int)(SWIG_As_int(obj1));
43625 if (SWIG_arg_fail(2)) SWIG_fail;
43626 }
43627 }
43628 {
43629 PyThreadState* __tstate = wxPyBeginAllowThreads();
43630 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43631
43632 wxPyEndAllowThreads(__tstate);
43633 if (PyErr_Occurred()) SWIG_fail;
43634 }
43635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43636 return resultobj;
43637 fail:
43638 return NULL;
43639 }
43640
43641
43642 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43643 PyObject *resultobj;
43644 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43645 PyObject *arg2 = (PyObject *) 0 ;
43646 wxGBPosition *arg3 = 0 ;
43647 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43648 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43649 int arg5 = (int) 0 ;
43650 int arg6 = (int) 0 ;
43651 PyObject *arg7 = (PyObject *) NULL ;
43652 wxGBSizerItem *result;
43653 wxGBPosition temp3 ;
43654 wxGBSpan temp4 ;
43655 PyObject * obj0 = 0 ;
43656 PyObject * obj1 = 0 ;
43657 PyObject * obj2 = 0 ;
43658 PyObject * obj3 = 0 ;
43659 PyObject * obj4 = 0 ;
43660 PyObject * obj5 = 0 ;
43661 PyObject * obj6 = 0 ;
43662 char *kwnames[] = {
43663 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43664 };
43665
43666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43668 if (SWIG_arg_fail(1)) SWIG_fail;
43669 arg2 = obj1;
43670 {
43671 arg3 = &temp3;
43672 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43673 }
43674 if (obj3) {
43675 {
43676 arg4 = &temp4;
43677 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43678 }
43679 }
43680 if (obj4) {
43681 {
43682 arg5 = (int)(SWIG_As_int(obj4));
43683 if (SWIG_arg_fail(5)) SWIG_fail;
43684 }
43685 }
43686 if (obj5) {
43687 {
43688 arg6 = (int)(SWIG_As_int(obj5));
43689 if (SWIG_arg_fail(6)) SWIG_fail;
43690 }
43691 }
43692 if (obj6) {
43693 arg7 = obj6;
43694 }
43695 {
43696 PyThreadState* __tstate = wxPyBeginAllowThreads();
43697 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43698
43699 wxPyEndAllowThreads(__tstate);
43700 if (PyErr_Occurred()) SWIG_fail;
43701 }
43702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43703 return resultobj;
43704 fail:
43705 return NULL;
43706 }
43707
43708
43709 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43710 PyObject *resultobj;
43711 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43712 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43713 wxGBSizerItem *result;
43714 PyObject * obj0 = 0 ;
43715 PyObject * obj1 = 0 ;
43716 char *kwnames[] = {
43717 (char *) "self",(char *) "item", NULL
43718 };
43719
43720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) 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_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43724 if (SWIG_arg_fail(2)) SWIG_fail;
43725 {
43726 PyThreadState* __tstate = wxPyBeginAllowThreads();
43727 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43728
43729 wxPyEndAllowThreads(__tstate);
43730 if (PyErr_Occurred()) SWIG_fail;
43731 }
43732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43733 return resultobj;
43734 fail:
43735 return NULL;
43736 }
43737
43738
43739 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43740 PyObject *resultobj;
43741 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43742 int arg2 ;
43743 int arg3 ;
43744 wxSize result;
43745 PyObject * obj0 = 0 ;
43746 PyObject * obj1 = 0 ;
43747 PyObject * obj2 = 0 ;
43748 char *kwnames[] = {
43749 (char *) "self",(char *) "row",(char *) "col", NULL
43750 };
43751
43752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43754 if (SWIG_arg_fail(1)) SWIG_fail;
43755 {
43756 arg2 = (int)(SWIG_As_int(obj1));
43757 if (SWIG_arg_fail(2)) SWIG_fail;
43758 }
43759 {
43760 arg3 = (int)(SWIG_As_int(obj2));
43761 if (SWIG_arg_fail(3)) SWIG_fail;
43762 }
43763 {
43764 PyThreadState* __tstate = wxPyBeginAllowThreads();
43765 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43766
43767 wxPyEndAllowThreads(__tstate);
43768 if (PyErr_Occurred()) SWIG_fail;
43769 }
43770 {
43771 wxSize * resultptr;
43772 resultptr = new wxSize((wxSize &)(result));
43773 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43774 }
43775 return resultobj;
43776 fail:
43777 return NULL;
43778 }
43779
43780
43781 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43782 PyObject *resultobj;
43783 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43784 wxSize result;
43785 PyObject * obj0 = 0 ;
43786 char *kwnames[] = {
43787 (char *) "self", NULL
43788 };
43789
43790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43792 if (SWIG_arg_fail(1)) SWIG_fail;
43793 {
43794 PyThreadState* __tstate = wxPyBeginAllowThreads();
43795 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43796
43797 wxPyEndAllowThreads(__tstate);
43798 if (PyErr_Occurred()) SWIG_fail;
43799 }
43800 {
43801 wxSize * resultptr;
43802 resultptr = new wxSize((wxSize &)(result));
43803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43804 }
43805 return resultobj;
43806 fail:
43807 return NULL;
43808 }
43809
43810
43811 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43812 PyObject *resultobj;
43813 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43814 wxSize *arg2 = 0 ;
43815 wxSize temp2 ;
43816 PyObject * obj0 = 0 ;
43817 PyObject * obj1 = 0 ;
43818 char *kwnames[] = {
43819 (char *) "self",(char *) "sz", NULL
43820 };
43821
43822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43824 if (SWIG_arg_fail(1)) SWIG_fail;
43825 {
43826 arg2 = &temp2;
43827 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43828 }
43829 {
43830 PyThreadState* __tstate = wxPyBeginAllowThreads();
43831 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43832
43833 wxPyEndAllowThreads(__tstate);
43834 if (PyErr_Occurred()) SWIG_fail;
43835 }
43836 Py_INCREF(Py_None); resultobj = Py_None;
43837 return resultobj;
43838 fail:
43839 return NULL;
43840 }
43841
43842
43843 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43844 PyObject *resultobj;
43845 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43846 wxWindow *arg2 = (wxWindow *) 0 ;
43847 wxGBPosition result;
43848 PyObject * obj0 = 0 ;
43849 PyObject * obj1 = 0 ;
43850
43851 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43853 if (SWIG_arg_fail(1)) SWIG_fail;
43854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43855 if (SWIG_arg_fail(2)) SWIG_fail;
43856 {
43857 PyThreadState* __tstate = wxPyBeginAllowThreads();
43858 result = (arg1)->GetItemPosition(arg2);
43859
43860 wxPyEndAllowThreads(__tstate);
43861 if (PyErr_Occurred()) SWIG_fail;
43862 }
43863 {
43864 wxGBPosition * resultptr;
43865 resultptr = new wxGBPosition((wxGBPosition &)(result));
43866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43867 }
43868 return resultobj;
43869 fail:
43870 return NULL;
43871 }
43872
43873
43874 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43875 PyObject *resultobj;
43876 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43877 wxSizer *arg2 = (wxSizer *) 0 ;
43878 wxGBPosition result;
43879 PyObject * obj0 = 0 ;
43880 PyObject * obj1 = 0 ;
43881
43882 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43884 if (SWIG_arg_fail(1)) SWIG_fail;
43885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43886 if (SWIG_arg_fail(2)) SWIG_fail;
43887 {
43888 PyThreadState* __tstate = wxPyBeginAllowThreads();
43889 result = (arg1)->GetItemPosition(arg2);
43890
43891 wxPyEndAllowThreads(__tstate);
43892 if (PyErr_Occurred()) SWIG_fail;
43893 }
43894 {
43895 wxGBPosition * resultptr;
43896 resultptr = new wxGBPosition((wxGBPosition &)(result));
43897 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43898 }
43899 return resultobj;
43900 fail:
43901 return NULL;
43902 }
43903
43904
43905 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43906 PyObject *resultobj;
43907 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43908 size_t arg2 ;
43909 wxGBPosition result;
43910 PyObject * obj0 = 0 ;
43911 PyObject * obj1 = 0 ;
43912
43913 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43915 if (SWIG_arg_fail(1)) SWIG_fail;
43916 {
43917 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43918 if (SWIG_arg_fail(2)) SWIG_fail;
43919 }
43920 {
43921 PyThreadState* __tstate = wxPyBeginAllowThreads();
43922 result = (arg1)->GetItemPosition(arg2);
43923
43924 wxPyEndAllowThreads(__tstate);
43925 if (PyErr_Occurred()) SWIG_fail;
43926 }
43927 {
43928 wxGBPosition * resultptr;
43929 resultptr = new wxGBPosition((wxGBPosition &)(result));
43930 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43931 }
43932 return resultobj;
43933 fail:
43934 return NULL;
43935 }
43936
43937
43938 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43939 int argc;
43940 PyObject *argv[3];
43941 int ii;
43942
43943 argc = PyObject_Length(args);
43944 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43945 argv[ii] = PyTuple_GetItem(args,ii);
43946 }
43947 if (argc == 2) {
43948 int _v;
43949 {
43950 void *ptr;
43951 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43952 _v = 0;
43953 PyErr_Clear();
43954 } else {
43955 _v = 1;
43956 }
43957 }
43958 if (_v) {
43959 {
43960 void *ptr;
43961 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43962 _v = 0;
43963 PyErr_Clear();
43964 } else {
43965 _v = 1;
43966 }
43967 }
43968 if (_v) {
43969 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43970 }
43971 }
43972 }
43973 if (argc == 2) {
43974 int _v;
43975 {
43976 void *ptr;
43977 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43978 _v = 0;
43979 PyErr_Clear();
43980 } else {
43981 _v = 1;
43982 }
43983 }
43984 if (_v) {
43985 {
43986 void *ptr;
43987 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43988 _v = 0;
43989 PyErr_Clear();
43990 } else {
43991 _v = 1;
43992 }
43993 }
43994 if (_v) {
43995 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43996 }
43997 }
43998 }
43999 if (argc == 2) {
44000 int _v;
44001 {
44002 void *ptr;
44003 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44004 _v = 0;
44005 PyErr_Clear();
44006 } else {
44007 _v = 1;
44008 }
44009 }
44010 if (_v) {
44011 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44012 if (_v) {
44013 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
44014 }
44015 }
44016 }
44017
44018 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
44019 return NULL;
44020 }
44021
44022
44023 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44024 PyObject *resultobj;
44025 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44026 wxWindow *arg2 = (wxWindow *) 0 ;
44027 wxGBPosition *arg3 = 0 ;
44028 bool result;
44029 wxGBPosition temp3 ;
44030 PyObject * obj0 = 0 ;
44031 PyObject * obj1 = 0 ;
44032 PyObject * obj2 = 0 ;
44033
44034 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44036 if (SWIG_arg_fail(1)) SWIG_fail;
44037 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44038 if (SWIG_arg_fail(2)) SWIG_fail;
44039 {
44040 arg3 = &temp3;
44041 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44042 }
44043 {
44044 PyThreadState* __tstate = wxPyBeginAllowThreads();
44045 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44046
44047 wxPyEndAllowThreads(__tstate);
44048 if (PyErr_Occurred()) SWIG_fail;
44049 }
44050 {
44051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44052 }
44053 return resultobj;
44054 fail:
44055 return NULL;
44056 }
44057
44058
44059 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44060 PyObject *resultobj;
44061 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44062 wxSizer *arg2 = (wxSizer *) 0 ;
44063 wxGBPosition *arg3 = 0 ;
44064 bool result;
44065 wxGBPosition temp3 ;
44066 PyObject * obj0 = 0 ;
44067 PyObject * obj1 = 0 ;
44068 PyObject * obj2 = 0 ;
44069
44070 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44072 if (SWIG_arg_fail(1)) SWIG_fail;
44073 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44074 if (SWIG_arg_fail(2)) SWIG_fail;
44075 {
44076 arg3 = &temp3;
44077 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44078 }
44079 {
44080 PyThreadState* __tstate = wxPyBeginAllowThreads();
44081 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44082
44083 wxPyEndAllowThreads(__tstate);
44084 if (PyErr_Occurred()) SWIG_fail;
44085 }
44086 {
44087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44088 }
44089 return resultobj;
44090 fail:
44091 return NULL;
44092 }
44093
44094
44095 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44096 PyObject *resultobj;
44097 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44098 size_t arg2 ;
44099 wxGBPosition *arg3 = 0 ;
44100 bool result;
44101 wxGBPosition temp3 ;
44102 PyObject * obj0 = 0 ;
44103 PyObject * obj1 = 0 ;
44104 PyObject * obj2 = 0 ;
44105
44106 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44108 if (SWIG_arg_fail(1)) SWIG_fail;
44109 {
44110 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44111 if (SWIG_arg_fail(2)) SWIG_fail;
44112 }
44113 {
44114 arg3 = &temp3;
44115 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44116 }
44117 {
44118 PyThreadState* __tstate = wxPyBeginAllowThreads();
44119 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44120
44121 wxPyEndAllowThreads(__tstate);
44122 if (PyErr_Occurred()) SWIG_fail;
44123 }
44124 {
44125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44126 }
44127 return resultobj;
44128 fail:
44129 return NULL;
44130 }
44131
44132
44133 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44134 int argc;
44135 PyObject *argv[4];
44136 int ii;
44137
44138 argc = PyObject_Length(args);
44139 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44140 argv[ii] = PyTuple_GetItem(args,ii);
44141 }
44142 if (argc == 3) {
44143 int _v;
44144 {
44145 void *ptr;
44146 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44147 _v = 0;
44148 PyErr_Clear();
44149 } else {
44150 _v = 1;
44151 }
44152 }
44153 if (_v) {
44154 {
44155 void *ptr;
44156 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44157 _v = 0;
44158 PyErr_Clear();
44159 } else {
44160 _v = 1;
44161 }
44162 }
44163 if (_v) {
44164 {
44165 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44166 }
44167 if (_v) {
44168 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44169 }
44170 }
44171 }
44172 }
44173 if (argc == 3) {
44174 int _v;
44175 {
44176 void *ptr;
44177 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44178 _v = 0;
44179 PyErr_Clear();
44180 } else {
44181 _v = 1;
44182 }
44183 }
44184 if (_v) {
44185 {
44186 void *ptr;
44187 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44188 _v = 0;
44189 PyErr_Clear();
44190 } else {
44191 _v = 1;
44192 }
44193 }
44194 if (_v) {
44195 {
44196 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44197 }
44198 if (_v) {
44199 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44200 }
44201 }
44202 }
44203 }
44204 if (argc == 3) {
44205 int _v;
44206 {
44207 void *ptr;
44208 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44209 _v = 0;
44210 PyErr_Clear();
44211 } else {
44212 _v = 1;
44213 }
44214 }
44215 if (_v) {
44216 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44217 if (_v) {
44218 {
44219 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44220 }
44221 if (_v) {
44222 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44223 }
44224 }
44225 }
44226 }
44227
44228 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44229 return NULL;
44230 }
44231
44232
44233 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44234 PyObject *resultobj;
44235 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44236 wxWindow *arg2 = (wxWindow *) 0 ;
44237 wxGBSpan result;
44238 PyObject * obj0 = 0 ;
44239 PyObject * obj1 = 0 ;
44240
44241 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44243 if (SWIG_arg_fail(1)) SWIG_fail;
44244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44245 if (SWIG_arg_fail(2)) SWIG_fail;
44246 {
44247 PyThreadState* __tstate = wxPyBeginAllowThreads();
44248 result = (arg1)->GetItemSpan(arg2);
44249
44250 wxPyEndAllowThreads(__tstate);
44251 if (PyErr_Occurred()) SWIG_fail;
44252 }
44253 {
44254 wxGBSpan * resultptr;
44255 resultptr = new wxGBSpan((wxGBSpan &)(result));
44256 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44257 }
44258 return resultobj;
44259 fail:
44260 return NULL;
44261 }
44262
44263
44264 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44265 PyObject *resultobj;
44266 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44267 wxSizer *arg2 = (wxSizer *) 0 ;
44268 wxGBSpan result;
44269 PyObject * obj0 = 0 ;
44270 PyObject * obj1 = 0 ;
44271
44272 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44274 if (SWIG_arg_fail(1)) SWIG_fail;
44275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44276 if (SWIG_arg_fail(2)) SWIG_fail;
44277 {
44278 PyThreadState* __tstate = wxPyBeginAllowThreads();
44279 result = (arg1)->GetItemSpan(arg2);
44280
44281 wxPyEndAllowThreads(__tstate);
44282 if (PyErr_Occurred()) SWIG_fail;
44283 }
44284 {
44285 wxGBSpan * resultptr;
44286 resultptr = new wxGBSpan((wxGBSpan &)(result));
44287 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44288 }
44289 return resultobj;
44290 fail:
44291 return NULL;
44292 }
44293
44294
44295 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44296 PyObject *resultobj;
44297 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44298 size_t arg2 ;
44299 wxGBSpan result;
44300 PyObject * obj0 = 0 ;
44301 PyObject * obj1 = 0 ;
44302
44303 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44305 if (SWIG_arg_fail(1)) SWIG_fail;
44306 {
44307 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44308 if (SWIG_arg_fail(2)) SWIG_fail;
44309 }
44310 {
44311 PyThreadState* __tstate = wxPyBeginAllowThreads();
44312 result = (arg1)->GetItemSpan(arg2);
44313
44314 wxPyEndAllowThreads(__tstate);
44315 if (PyErr_Occurred()) SWIG_fail;
44316 }
44317 {
44318 wxGBSpan * resultptr;
44319 resultptr = new wxGBSpan((wxGBSpan &)(result));
44320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44321 }
44322 return resultobj;
44323 fail:
44324 return NULL;
44325 }
44326
44327
44328 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44329 int argc;
44330 PyObject *argv[3];
44331 int ii;
44332
44333 argc = PyObject_Length(args);
44334 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44335 argv[ii] = PyTuple_GetItem(args,ii);
44336 }
44337 if (argc == 2) {
44338 int _v;
44339 {
44340 void *ptr;
44341 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44342 _v = 0;
44343 PyErr_Clear();
44344 } else {
44345 _v = 1;
44346 }
44347 }
44348 if (_v) {
44349 {
44350 void *ptr;
44351 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44352 _v = 0;
44353 PyErr_Clear();
44354 } else {
44355 _v = 1;
44356 }
44357 }
44358 if (_v) {
44359 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44360 }
44361 }
44362 }
44363 if (argc == 2) {
44364 int _v;
44365 {
44366 void *ptr;
44367 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44368 _v = 0;
44369 PyErr_Clear();
44370 } else {
44371 _v = 1;
44372 }
44373 }
44374 if (_v) {
44375 {
44376 void *ptr;
44377 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44378 _v = 0;
44379 PyErr_Clear();
44380 } else {
44381 _v = 1;
44382 }
44383 }
44384 if (_v) {
44385 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44386 }
44387 }
44388 }
44389 if (argc == 2) {
44390 int _v;
44391 {
44392 void *ptr;
44393 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44394 _v = 0;
44395 PyErr_Clear();
44396 } else {
44397 _v = 1;
44398 }
44399 }
44400 if (_v) {
44401 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44402 if (_v) {
44403 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44404 }
44405 }
44406 }
44407
44408 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44409 return NULL;
44410 }
44411
44412
44413 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44414 PyObject *resultobj;
44415 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44416 wxWindow *arg2 = (wxWindow *) 0 ;
44417 wxGBSpan *arg3 = 0 ;
44418 bool result;
44419 wxGBSpan temp3 ;
44420 PyObject * obj0 = 0 ;
44421 PyObject * obj1 = 0 ;
44422 PyObject * obj2 = 0 ;
44423
44424 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44426 if (SWIG_arg_fail(1)) SWIG_fail;
44427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44428 if (SWIG_arg_fail(2)) SWIG_fail;
44429 {
44430 arg3 = &temp3;
44431 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44432 }
44433 {
44434 PyThreadState* __tstate = wxPyBeginAllowThreads();
44435 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44436
44437 wxPyEndAllowThreads(__tstate);
44438 if (PyErr_Occurred()) SWIG_fail;
44439 }
44440 {
44441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44442 }
44443 return resultobj;
44444 fail:
44445 return NULL;
44446 }
44447
44448
44449 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44450 PyObject *resultobj;
44451 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44452 wxSizer *arg2 = (wxSizer *) 0 ;
44453 wxGBSpan *arg3 = 0 ;
44454 bool result;
44455 wxGBSpan temp3 ;
44456 PyObject * obj0 = 0 ;
44457 PyObject * obj1 = 0 ;
44458 PyObject * obj2 = 0 ;
44459
44460 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44462 if (SWIG_arg_fail(1)) SWIG_fail;
44463 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44464 if (SWIG_arg_fail(2)) SWIG_fail;
44465 {
44466 arg3 = &temp3;
44467 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44468 }
44469 {
44470 PyThreadState* __tstate = wxPyBeginAllowThreads();
44471 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44472
44473 wxPyEndAllowThreads(__tstate);
44474 if (PyErr_Occurred()) SWIG_fail;
44475 }
44476 {
44477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44478 }
44479 return resultobj;
44480 fail:
44481 return NULL;
44482 }
44483
44484
44485 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44486 PyObject *resultobj;
44487 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44488 size_t arg2 ;
44489 wxGBSpan *arg3 = 0 ;
44490 bool result;
44491 wxGBSpan temp3 ;
44492 PyObject * obj0 = 0 ;
44493 PyObject * obj1 = 0 ;
44494 PyObject * obj2 = 0 ;
44495
44496 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44498 if (SWIG_arg_fail(1)) SWIG_fail;
44499 {
44500 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44501 if (SWIG_arg_fail(2)) SWIG_fail;
44502 }
44503 {
44504 arg3 = &temp3;
44505 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44506 }
44507 {
44508 PyThreadState* __tstate = wxPyBeginAllowThreads();
44509 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44510
44511 wxPyEndAllowThreads(__tstate);
44512 if (PyErr_Occurred()) SWIG_fail;
44513 }
44514 {
44515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44516 }
44517 return resultobj;
44518 fail:
44519 return NULL;
44520 }
44521
44522
44523 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44524 int argc;
44525 PyObject *argv[4];
44526 int ii;
44527
44528 argc = PyObject_Length(args);
44529 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44530 argv[ii] = PyTuple_GetItem(args,ii);
44531 }
44532 if (argc == 3) {
44533 int _v;
44534 {
44535 void *ptr;
44536 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44537 _v = 0;
44538 PyErr_Clear();
44539 } else {
44540 _v = 1;
44541 }
44542 }
44543 if (_v) {
44544 {
44545 void *ptr;
44546 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44547 _v = 0;
44548 PyErr_Clear();
44549 } else {
44550 _v = 1;
44551 }
44552 }
44553 if (_v) {
44554 {
44555 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44556 }
44557 if (_v) {
44558 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44559 }
44560 }
44561 }
44562 }
44563 if (argc == 3) {
44564 int _v;
44565 {
44566 void *ptr;
44567 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44568 _v = 0;
44569 PyErr_Clear();
44570 } else {
44571 _v = 1;
44572 }
44573 }
44574 if (_v) {
44575 {
44576 void *ptr;
44577 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44578 _v = 0;
44579 PyErr_Clear();
44580 } else {
44581 _v = 1;
44582 }
44583 }
44584 if (_v) {
44585 {
44586 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44587 }
44588 if (_v) {
44589 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44590 }
44591 }
44592 }
44593 }
44594 if (argc == 3) {
44595 int _v;
44596 {
44597 void *ptr;
44598 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44599 _v = 0;
44600 PyErr_Clear();
44601 } else {
44602 _v = 1;
44603 }
44604 }
44605 if (_v) {
44606 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44607 if (_v) {
44608 {
44609 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44610 }
44611 if (_v) {
44612 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
44613 }
44614 }
44615 }
44616 }
44617
44618 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44619 return NULL;
44620 }
44621
44622
44623 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44624 PyObject *resultobj;
44625 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44626 wxWindow *arg2 = (wxWindow *) 0 ;
44627 wxGBSizerItem *result;
44628 PyObject * obj0 = 0 ;
44629 PyObject * obj1 = 0 ;
44630
44631 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44633 if (SWIG_arg_fail(1)) SWIG_fail;
44634 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44635 if (SWIG_arg_fail(2)) SWIG_fail;
44636 {
44637 PyThreadState* __tstate = wxPyBeginAllowThreads();
44638 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44639
44640 wxPyEndAllowThreads(__tstate);
44641 if (PyErr_Occurred()) SWIG_fail;
44642 }
44643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44644 return resultobj;
44645 fail:
44646 return NULL;
44647 }
44648
44649
44650 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44651 PyObject *resultobj;
44652 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44653 wxSizer *arg2 = (wxSizer *) 0 ;
44654 wxGBSizerItem *result;
44655 PyObject * obj0 = 0 ;
44656 PyObject * obj1 = 0 ;
44657
44658 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44660 if (SWIG_arg_fail(1)) SWIG_fail;
44661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44662 if (SWIG_arg_fail(2)) SWIG_fail;
44663 {
44664 PyThreadState* __tstate = wxPyBeginAllowThreads();
44665 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44666
44667 wxPyEndAllowThreads(__tstate);
44668 if (PyErr_Occurred()) SWIG_fail;
44669 }
44670 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44671 return resultobj;
44672 fail:
44673 return NULL;
44674 }
44675
44676
44677 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44678 int argc;
44679 PyObject *argv[3];
44680 int ii;
44681
44682 argc = PyObject_Length(args);
44683 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44684 argv[ii] = PyTuple_GetItem(args,ii);
44685 }
44686 if (argc == 2) {
44687 int _v;
44688 {
44689 void *ptr;
44690 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44691 _v = 0;
44692 PyErr_Clear();
44693 } else {
44694 _v = 1;
44695 }
44696 }
44697 if (_v) {
44698 {
44699 void *ptr;
44700 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44701 _v = 0;
44702 PyErr_Clear();
44703 } else {
44704 _v = 1;
44705 }
44706 }
44707 if (_v) {
44708 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44709 }
44710 }
44711 }
44712 if (argc == 2) {
44713 int _v;
44714 {
44715 void *ptr;
44716 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44717 _v = 0;
44718 PyErr_Clear();
44719 } else {
44720 _v = 1;
44721 }
44722 }
44723 if (_v) {
44724 {
44725 void *ptr;
44726 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44727 _v = 0;
44728 PyErr_Clear();
44729 } else {
44730 _v = 1;
44731 }
44732 }
44733 if (_v) {
44734 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44735 }
44736 }
44737 }
44738
44739 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44740 return NULL;
44741 }
44742
44743
44744 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44745 PyObject *resultobj;
44746 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44747 wxGBPosition *arg2 = 0 ;
44748 wxGBSizerItem *result;
44749 wxGBPosition temp2 ;
44750 PyObject * obj0 = 0 ;
44751 PyObject * obj1 = 0 ;
44752 char *kwnames[] = {
44753 (char *) "self",(char *) "pos", NULL
44754 };
44755
44756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44758 if (SWIG_arg_fail(1)) SWIG_fail;
44759 {
44760 arg2 = &temp2;
44761 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44762 }
44763 {
44764 PyThreadState* __tstate = wxPyBeginAllowThreads();
44765 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44766
44767 wxPyEndAllowThreads(__tstate);
44768 if (PyErr_Occurred()) SWIG_fail;
44769 }
44770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44771 return resultobj;
44772 fail:
44773 return NULL;
44774 }
44775
44776
44777 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44778 PyObject *resultobj;
44779 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44780 wxPoint *arg2 = 0 ;
44781 wxGBSizerItem *result;
44782 wxPoint temp2 ;
44783 PyObject * obj0 = 0 ;
44784 PyObject * obj1 = 0 ;
44785 char *kwnames[] = {
44786 (char *) "self",(char *) "pt", NULL
44787 };
44788
44789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44791 if (SWIG_arg_fail(1)) SWIG_fail;
44792 {
44793 arg2 = &temp2;
44794 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44795 }
44796 {
44797 PyThreadState* __tstate = wxPyBeginAllowThreads();
44798 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44799
44800 wxPyEndAllowThreads(__tstate);
44801 if (PyErr_Occurred()) SWIG_fail;
44802 }
44803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44804 return resultobj;
44805 fail:
44806 return NULL;
44807 }
44808
44809
44810 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44811 PyObject *resultobj;
44812 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44813 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44814 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44815 bool result;
44816 PyObject * obj0 = 0 ;
44817 PyObject * obj1 = 0 ;
44818 PyObject * obj2 = 0 ;
44819 char *kwnames[] = {
44820 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44821 };
44822
44823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44825 if (SWIG_arg_fail(1)) SWIG_fail;
44826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44827 if (SWIG_arg_fail(2)) SWIG_fail;
44828 if (obj2) {
44829 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44830 if (SWIG_arg_fail(3)) SWIG_fail;
44831 }
44832 {
44833 PyThreadState* __tstate = wxPyBeginAllowThreads();
44834 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44835
44836 wxPyEndAllowThreads(__tstate);
44837 if (PyErr_Occurred()) SWIG_fail;
44838 }
44839 {
44840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44841 }
44842 return resultobj;
44843 fail:
44844 return NULL;
44845 }
44846
44847
44848 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44849 PyObject *resultobj;
44850 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44851 wxGBPosition *arg2 = 0 ;
44852 wxGBSpan *arg3 = 0 ;
44853 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44854 bool result;
44855 wxGBPosition temp2 ;
44856 wxGBSpan temp3 ;
44857 PyObject * obj0 = 0 ;
44858 PyObject * obj1 = 0 ;
44859 PyObject * obj2 = 0 ;
44860 PyObject * obj3 = 0 ;
44861 char *kwnames[] = {
44862 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44863 };
44864
44865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44867 if (SWIG_arg_fail(1)) SWIG_fail;
44868 {
44869 arg2 = &temp2;
44870 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44871 }
44872 {
44873 arg3 = &temp3;
44874 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44875 }
44876 if (obj3) {
44877 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44878 if (SWIG_arg_fail(4)) SWIG_fail;
44879 }
44880 {
44881 PyThreadState* __tstate = wxPyBeginAllowThreads();
44882 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44883
44884 wxPyEndAllowThreads(__tstate);
44885 if (PyErr_Occurred()) SWIG_fail;
44886 }
44887 {
44888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44889 }
44890 return resultobj;
44891 fail:
44892 return NULL;
44893 }
44894
44895
44896 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44897 PyObject *obj;
44898 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44899 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44900 Py_INCREF(obj);
44901 return Py_BuildValue((char *)"");
44902 }
44903 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44904 PyObject *resultobj;
44905 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44906 wxRelationship arg2 ;
44907 wxWindow *arg3 = (wxWindow *) 0 ;
44908 wxEdge arg4 ;
44909 int arg5 = (int) 0 ;
44910 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44911 PyObject * obj0 = 0 ;
44912 PyObject * obj1 = 0 ;
44913 PyObject * obj2 = 0 ;
44914 PyObject * obj3 = 0 ;
44915 PyObject * obj4 = 0 ;
44916 PyObject * obj5 = 0 ;
44917 char *kwnames[] = {
44918 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44919 };
44920
44921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44923 if (SWIG_arg_fail(1)) SWIG_fail;
44924 {
44925 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44926 if (SWIG_arg_fail(2)) SWIG_fail;
44927 }
44928 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44929 if (SWIG_arg_fail(3)) SWIG_fail;
44930 {
44931 arg4 = (wxEdge)(SWIG_As_int(obj3));
44932 if (SWIG_arg_fail(4)) SWIG_fail;
44933 }
44934 if (obj4) {
44935 {
44936 arg5 = (int)(SWIG_As_int(obj4));
44937 if (SWIG_arg_fail(5)) SWIG_fail;
44938 }
44939 }
44940 if (obj5) {
44941 {
44942 arg6 = (int)(SWIG_As_int(obj5));
44943 if (SWIG_arg_fail(6)) SWIG_fail;
44944 }
44945 }
44946 {
44947 PyThreadState* __tstate = wxPyBeginAllowThreads();
44948 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44949
44950 wxPyEndAllowThreads(__tstate);
44951 if (PyErr_Occurred()) SWIG_fail;
44952 }
44953 Py_INCREF(Py_None); resultobj = Py_None;
44954 return resultobj;
44955 fail:
44956 return NULL;
44957 }
44958
44959
44960 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44961 PyObject *resultobj;
44962 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44963 wxWindow *arg2 = (wxWindow *) 0 ;
44964 int arg3 = (int) 0 ;
44965 PyObject * obj0 = 0 ;
44966 PyObject * obj1 = 0 ;
44967 PyObject * obj2 = 0 ;
44968 char *kwnames[] = {
44969 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44970 };
44971
44972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44974 if (SWIG_arg_fail(1)) SWIG_fail;
44975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44976 if (SWIG_arg_fail(2)) SWIG_fail;
44977 if (obj2) {
44978 {
44979 arg3 = (int)(SWIG_As_int(obj2));
44980 if (SWIG_arg_fail(3)) SWIG_fail;
44981 }
44982 }
44983 {
44984 PyThreadState* __tstate = wxPyBeginAllowThreads();
44985 (arg1)->LeftOf(arg2,arg3);
44986
44987 wxPyEndAllowThreads(__tstate);
44988 if (PyErr_Occurred()) SWIG_fail;
44989 }
44990 Py_INCREF(Py_None); resultobj = Py_None;
44991 return resultobj;
44992 fail:
44993 return NULL;
44994 }
44995
44996
44997 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44998 PyObject *resultobj;
44999 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45000 wxWindow *arg2 = (wxWindow *) 0 ;
45001 int arg3 = (int) 0 ;
45002 PyObject * obj0 = 0 ;
45003 PyObject * obj1 = 0 ;
45004 PyObject * obj2 = 0 ;
45005 char *kwnames[] = {
45006 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45007 };
45008
45009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45011 if (SWIG_arg_fail(1)) SWIG_fail;
45012 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45013 if (SWIG_arg_fail(2)) SWIG_fail;
45014 if (obj2) {
45015 {
45016 arg3 = (int)(SWIG_As_int(obj2));
45017 if (SWIG_arg_fail(3)) SWIG_fail;
45018 }
45019 }
45020 {
45021 PyThreadState* __tstate = wxPyBeginAllowThreads();
45022 (arg1)->RightOf(arg2,arg3);
45023
45024 wxPyEndAllowThreads(__tstate);
45025 if (PyErr_Occurred()) SWIG_fail;
45026 }
45027 Py_INCREF(Py_None); resultobj = Py_None;
45028 return resultobj;
45029 fail:
45030 return NULL;
45031 }
45032
45033
45034 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
45035 PyObject *resultobj;
45036 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45037 wxWindow *arg2 = (wxWindow *) 0 ;
45038 int arg3 = (int) 0 ;
45039 PyObject * obj0 = 0 ;
45040 PyObject * obj1 = 0 ;
45041 PyObject * obj2 = 0 ;
45042 char *kwnames[] = {
45043 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45044 };
45045
45046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
45047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45048 if (SWIG_arg_fail(1)) SWIG_fail;
45049 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45050 if (SWIG_arg_fail(2)) SWIG_fail;
45051 if (obj2) {
45052 {
45053 arg3 = (int)(SWIG_As_int(obj2));
45054 if (SWIG_arg_fail(3)) SWIG_fail;
45055 }
45056 }
45057 {
45058 PyThreadState* __tstate = wxPyBeginAllowThreads();
45059 (arg1)->Above(arg2,arg3);
45060
45061 wxPyEndAllowThreads(__tstate);
45062 if (PyErr_Occurred()) SWIG_fail;
45063 }
45064 Py_INCREF(Py_None); resultobj = Py_None;
45065 return resultobj;
45066 fail:
45067 return NULL;
45068 }
45069
45070
45071 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
45072 PyObject *resultobj;
45073 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45074 wxWindow *arg2 = (wxWindow *) 0 ;
45075 int arg3 = (int) 0 ;
45076 PyObject * obj0 = 0 ;
45077 PyObject * obj1 = 0 ;
45078 PyObject * obj2 = 0 ;
45079 char *kwnames[] = {
45080 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45081 };
45082
45083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
45084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45085 if (SWIG_arg_fail(1)) SWIG_fail;
45086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45087 if (SWIG_arg_fail(2)) SWIG_fail;
45088 if (obj2) {
45089 {
45090 arg3 = (int)(SWIG_As_int(obj2));
45091 if (SWIG_arg_fail(3)) SWIG_fail;
45092 }
45093 }
45094 {
45095 PyThreadState* __tstate = wxPyBeginAllowThreads();
45096 (arg1)->Below(arg2,arg3);
45097
45098 wxPyEndAllowThreads(__tstate);
45099 if (PyErr_Occurred()) SWIG_fail;
45100 }
45101 Py_INCREF(Py_None); resultobj = Py_None;
45102 return resultobj;
45103 fail:
45104 return NULL;
45105 }
45106
45107
45108 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45109 PyObject *resultobj;
45110 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45111 wxWindow *arg2 = (wxWindow *) 0 ;
45112 wxEdge arg3 ;
45113 int arg4 = (int) 0 ;
45114 PyObject * obj0 = 0 ;
45115 PyObject * obj1 = 0 ;
45116 PyObject * obj2 = 0 ;
45117 PyObject * obj3 = 0 ;
45118 char *kwnames[] = {
45119 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45120 };
45121
45122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45124 if (SWIG_arg_fail(1)) SWIG_fail;
45125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45126 if (SWIG_arg_fail(2)) SWIG_fail;
45127 {
45128 arg3 = (wxEdge)(SWIG_As_int(obj2));
45129 if (SWIG_arg_fail(3)) SWIG_fail;
45130 }
45131 if (obj3) {
45132 {
45133 arg4 = (int)(SWIG_As_int(obj3));
45134 if (SWIG_arg_fail(4)) SWIG_fail;
45135 }
45136 }
45137 {
45138 PyThreadState* __tstate = wxPyBeginAllowThreads();
45139 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
45140
45141 wxPyEndAllowThreads(__tstate);
45142 if (PyErr_Occurred()) SWIG_fail;
45143 }
45144 Py_INCREF(Py_None); resultobj = Py_None;
45145 return resultobj;
45146 fail:
45147 return NULL;
45148 }
45149
45150
45151 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45152 PyObject *resultobj;
45153 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45154 wxWindow *arg2 = (wxWindow *) 0 ;
45155 wxEdge arg3 ;
45156 int arg4 ;
45157 PyObject * obj0 = 0 ;
45158 PyObject * obj1 = 0 ;
45159 PyObject * obj2 = 0 ;
45160 PyObject * obj3 = 0 ;
45161 char *kwnames[] = {
45162 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45163 };
45164
45165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45167 if (SWIG_arg_fail(1)) SWIG_fail;
45168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45169 if (SWIG_arg_fail(2)) SWIG_fail;
45170 {
45171 arg3 = (wxEdge)(SWIG_As_int(obj2));
45172 if (SWIG_arg_fail(3)) SWIG_fail;
45173 }
45174 {
45175 arg4 = (int)(SWIG_As_int(obj3));
45176 if (SWIG_arg_fail(4)) SWIG_fail;
45177 }
45178 {
45179 PyThreadState* __tstate = wxPyBeginAllowThreads();
45180 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
45181
45182 wxPyEndAllowThreads(__tstate);
45183 if (PyErr_Occurred()) SWIG_fail;
45184 }
45185 Py_INCREF(Py_None); resultobj = Py_None;
45186 return resultobj;
45187 fail:
45188 return NULL;
45189 }
45190
45191
45192 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45193 PyObject *resultobj;
45194 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45195 int arg2 ;
45196 PyObject * obj0 = 0 ;
45197 PyObject * obj1 = 0 ;
45198 char *kwnames[] = {
45199 (char *) "self",(char *) "val", NULL
45200 };
45201
45202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45204 if (SWIG_arg_fail(1)) SWIG_fail;
45205 {
45206 arg2 = (int)(SWIG_As_int(obj1));
45207 if (SWIG_arg_fail(2)) SWIG_fail;
45208 }
45209 {
45210 PyThreadState* __tstate = wxPyBeginAllowThreads();
45211 (arg1)->Absolute(arg2);
45212
45213 wxPyEndAllowThreads(__tstate);
45214 if (PyErr_Occurred()) SWIG_fail;
45215 }
45216 Py_INCREF(Py_None); resultobj = Py_None;
45217 return resultobj;
45218 fail:
45219 return NULL;
45220 }
45221
45222
45223 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45224 PyObject *resultobj;
45225 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45226 PyObject * obj0 = 0 ;
45227 char *kwnames[] = {
45228 (char *) "self", NULL
45229 };
45230
45231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45233 if (SWIG_arg_fail(1)) SWIG_fail;
45234 {
45235 PyThreadState* __tstate = wxPyBeginAllowThreads();
45236 (arg1)->Unconstrained();
45237
45238 wxPyEndAllowThreads(__tstate);
45239 if (PyErr_Occurred()) SWIG_fail;
45240 }
45241 Py_INCREF(Py_None); resultobj = Py_None;
45242 return resultobj;
45243 fail:
45244 return NULL;
45245 }
45246
45247
45248 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45249 PyObject *resultobj;
45250 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45251 PyObject * obj0 = 0 ;
45252 char *kwnames[] = {
45253 (char *) "self", NULL
45254 };
45255
45256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45258 if (SWIG_arg_fail(1)) SWIG_fail;
45259 {
45260 PyThreadState* __tstate = wxPyBeginAllowThreads();
45261 (arg1)->AsIs();
45262
45263 wxPyEndAllowThreads(__tstate);
45264 if (PyErr_Occurred()) SWIG_fail;
45265 }
45266 Py_INCREF(Py_None); resultobj = Py_None;
45267 return resultobj;
45268 fail:
45269 return NULL;
45270 }
45271
45272
45273 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45274 PyObject *resultobj;
45275 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45276 wxWindow *result;
45277 PyObject * obj0 = 0 ;
45278 char *kwnames[] = {
45279 (char *) "self", NULL
45280 };
45281
45282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45284 if (SWIG_arg_fail(1)) SWIG_fail;
45285 {
45286 PyThreadState* __tstate = wxPyBeginAllowThreads();
45287 result = (wxWindow *)(arg1)->GetOtherWindow();
45288
45289 wxPyEndAllowThreads(__tstate);
45290 if (PyErr_Occurred()) SWIG_fail;
45291 }
45292 {
45293 resultobj = wxPyMake_wxObject(result, 0);
45294 }
45295 return resultobj;
45296 fail:
45297 return NULL;
45298 }
45299
45300
45301 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45302 PyObject *resultobj;
45303 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45304 wxEdge result;
45305 PyObject * obj0 = 0 ;
45306 char *kwnames[] = {
45307 (char *) "self", NULL
45308 };
45309
45310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45312 if (SWIG_arg_fail(1)) SWIG_fail;
45313 {
45314 PyThreadState* __tstate = wxPyBeginAllowThreads();
45315 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45316
45317 wxPyEndAllowThreads(__tstate);
45318 if (PyErr_Occurred()) SWIG_fail;
45319 }
45320 resultobj = SWIG_From_int((result));
45321 return resultobj;
45322 fail:
45323 return NULL;
45324 }
45325
45326
45327 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45328 PyObject *resultobj;
45329 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45330 wxEdge arg2 ;
45331 PyObject * obj0 = 0 ;
45332 PyObject * obj1 = 0 ;
45333 char *kwnames[] = {
45334 (char *) "self",(char *) "which", NULL
45335 };
45336
45337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45339 if (SWIG_arg_fail(1)) SWIG_fail;
45340 {
45341 arg2 = (wxEdge)(SWIG_As_int(obj1));
45342 if (SWIG_arg_fail(2)) SWIG_fail;
45343 }
45344 {
45345 PyThreadState* __tstate = wxPyBeginAllowThreads();
45346 (arg1)->SetEdge((wxEdge )arg2);
45347
45348 wxPyEndAllowThreads(__tstate);
45349 if (PyErr_Occurred()) SWIG_fail;
45350 }
45351 Py_INCREF(Py_None); resultobj = Py_None;
45352 return resultobj;
45353 fail:
45354 return NULL;
45355 }
45356
45357
45358 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45359 PyObject *resultobj;
45360 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45361 int arg2 ;
45362 PyObject * obj0 = 0 ;
45363 PyObject * obj1 = 0 ;
45364 char *kwnames[] = {
45365 (char *) "self",(char *) "v", NULL
45366 };
45367
45368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45370 if (SWIG_arg_fail(1)) SWIG_fail;
45371 {
45372 arg2 = (int)(SWIG_As_int(obj1));
45373 if (SWIG_arg_fail(2)) SWIG_fail;
45374 }
45375 {
45376 PyThreadState* __tstate = wxPyBeginAllowThreads();
45377 (arg1)->SetValue(arg2);
45378
45379 wxPyEndAllowThreads(__tstate);
45380 if (PyErr_Occurred()) SWIG_fail;
45381 }
45382 Py_INCREF(Py_None); resultobj = Py_None;
45383 return resultobj;
45384 fail:
45385 return NULL;
45386 }
45387
45388
45389 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45390 PyObject *resultobj;
45391 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45392 int result;
45393 PyObject * obj0 = 0 ;
45394 char *kwnames[] = {
45395 (char *) "self", NULL
45396 };
45397
45398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45400 if (SWIG_arg_fail(1)) SWIG_fail;
45401 {
45402 PyThreadState* __tstate = wxPyBeginAllowThreads();
45403 result = (int)(arg1)->GetMargin();
45404
45405 wxPyEndAllowThreads(__tstate);
45406 if (PyErr_Occurred()) SWIG_fail;
45407 }
45408 {
45409 resultobj = SWIG_From_int((int)(result));
45410 }
45411 return resultobj;
45412 fail:
45413 return NULL;
45414 }
45415
45416
45417 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45418 PyObject *resultobj;
45419 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45420 int arg2 ;
45421 PyObject * obj0 = 0 ;
45422 PyObject * obj1 = 0 ;
45423 char *kwnames[] = {
45424 (char *) "self",(char *) "m", NULL
45425 };
45426
45427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45429 if (SWIG_arg_fail(1)) SWIG_fail;
45430 {
45431 arg2 = (int)(SWIG_As_int(obj1));
45432 if (SWIG_arg_fail(2)) SWIG_fail;
45433 }
45434 {
45435 PyThreadState* __tstate = wxPyBeginAllowThreads();
45436 (arg1)->SetMargin(arg2);
45437
45438 wxPyEndAllowThreads(__tstate);
45439 if (PyErr_Occurred()) SWIG_fail;
45440 }
45441 Py_INCREF(Py_None); resultobj = Py_None;
45442 return resultobj;
45443 fail:
45444 return NULL;
45445 }
45446
45447
45448 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45449 PyObject *resultobj;
45450 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45451 int result;
45452 PyObject * obj0 = 0 ;
45453 char *kwnames[] = {
45454 (char *) "self", NULL
45455 };
45456
45457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45459 if (SWIG_arg_fail(1)) SWIG_fail;
45460 {
45461 PyThreadState* __tstate = wxPyBeginAllowThreads();
45462 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45463
45464 wxPyEndAllowThreads(__tstate);
45465 if (PyErr_Occurred()) SWIG_fail;
45466 }
45467 {
45468 resultobj = SWIG_From_int((int)(result));
45469 }
45470 return resultobj;
45471 fail:
45472 return NULL;
45473 }
45474
45475
45476 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45477 PyObject *resultobj;
45478 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45479 int result;
45480 PyObject * obj0 = 0 ;
45481 char *kwnames[] = {
45482 (char *) "self", NULL
45483 };
45484
45485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45487 if (SWIG_arg_fail(1)) SWIG_fail;
45488 {
45489 PyThreadState* __tstate = wxPyBeginAllowThreads();
45490 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45491
45492 wxPyEndAllowThreads(__tstate);
45493 if (PyErr_Occurred()) SWIG_fail;
45494 }
45495 {
45496 resultobj = SWIG_From_int((int)(result));
45497 }
45498 return resultobj;
45499 fail:
45500 return NULL;
45501 }
45502
45503
45504 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45505 PyObject *resultobj;
45506 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45507 int result;
45508 PyObject * obj0 = 0 ;
45509 char *kwnames[] = {
45510 (char *) "self", NULL
45511 };
45512
45513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45515 if (SWIG_arg_fail(1)) SWIG_fail;
45516 {
45517 PyThreadState* __tstate = wxPyBeginAllowThreads();
45518 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45519
45520 wxPyEndAllowThreads(__tstate);
45521 if (PyErr_Occurred()) SWIG_fail;
45522 }
45523 {
45524 resultobj = SWIG_From_int((int)(result));
45525 }
45526 return resultobj;
45527 fail:
45528 return NULL;
45529 }
45530
45531
45532 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45533 PyObject *resultobj;
45534 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45535 bool result;
45536 PyObject * obj0 = 0 ;
45537 char *kwnames[] = {
45538 (char *) "self", NULL
45539 };
45540
45541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45543 if (SWIG_arg_fail(1)) SWIG_fail;
45544 {
45545 PyThreadState* __tstate = wxPyBeginAllowThreads();
45546 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45547
45548 wxPyEndAllowThreads(__tstate);
45549 if (PyErr_Occurred()) SWIG_fail;
45550 }
45551 {
45552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45553 }
45554 return resultobj;
45555 fail:
45556 return NULL;
45557 }
45558
45559
45560 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45561 PyObject *resultobj;
45562 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45563 bool arg2 ;
45564 PyObject * obj0 = 0 ;
45565 PyObject * obj1 = 0 ;
45566 char *kwnames[] = {
45567 (char *) "self",(char *) "d", NULL
45568 };
45569
45570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45572 if (SWIG_arg_fail(1)) SWIG_fail;
45573 {
45574 arg2 = (bool)(SWIG_As_bool(obj1));
45575 if (SWIG_arg_fail(2)) SWIG_fail;
45576 }
45577 {
45578 PyThreadState* __tstate = wxPyBeginAllowThreads();
45579 (arg1)->SetDone(arg2);
45580
45581 wxPyEndAllowThreads(__tstate);
45582 if (PyErr_Occurred()) SWIG_fail;
45583 }
45584 Py_INCREF(Py_None); resultobj = Py_None;
45585 return resultobj;
45586 fail:
45587 return NULL;
45588 }
45589
45590
45591 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45592 PyObject *resultobj;
45593 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45594 wxRelationship result;
45595 PyObject * obj0 = 0 ;
45596 char *kwnames[] = {
45597 (char *) "self", NULL
45598 };
45599
45600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45602 if (SWIG_arg_fail(1)) SWIG_fail;
45603 {
45604 PyThreadState* __tstate = wxPyBeginAllowThreads();
45605 result = (wxRelationship)(arg1)->GetRelationship();
45606
45607 wxPyEndAllowThreads(__tstate);
45608 if (PyErr_Occurred()) SWIG_fail;
45609 }
45610 resultobj = SWIG_From_int((result));
45611 return resultobj;
45612 fail:
45613 return NULL;
45614 }
45615
45616
45617 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45618 PyObject *resultobj;
45619 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45620 wxRelationship arg2 ;
45621 PyObject * obj0 = 0 ;
45622 PyObject * obj1 = 0 ;
45623 char *kwnames[] = {
45624 (char *) "self",(char *) "r", NULL
45625 };
45626
45627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45629 if (SWIG_arg_fail(1)) SWIG_fail;
45630 {
45631 arg2 = (wxRelationship)(SWIG_As_int(obj1));
45632 if (SWIG_arg_fail(2)) SWIG_fail;
45633 }
45634 {
45635 PyThreadState* __tstate = wxPyBeginAllowThreads();
45636 (arg1)->SetRelationship((wxRelationship )arg2);
45637
45638 wxPyEndAllowThreads(__tstate);
45639 if (PyErr_Occurred()) SWIG_fail;
45640 }
45641 Py_INCREF(Py_None); resultobj = Py_None;
45642 return resultobj;
45643 fail:
45644 return NULL;
45645 }
45646
45647
45648 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45649 PyObject *resultobj;
45650 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45651 wxWindow *arg2 = (wxWindow *) 0 ;
45652 bool result;
45653 PyObject * obj0 = 0 ;
45654 PyObject * obj1 = 0 ;
45655 char *kwnames[] = {
45656 (char *) "self",(char *) "otherW", NULL
45657 };
45658
45659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45661 if (SWIG_arg_fail(1)) SWIG_fail;
45662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45663 if (SWIG_arg_fail(2)) SWIG_fail;
45664 {
45665 PyThreadState* __tstate = wxPyBeginAllowThreads();
45666 result = (bool)(arg1)->ResetIfWin(arg2);
45667
45668 wxPyEndAllowThreads(__tstate);
45669 if (PyErr_Occurred()) SWIG_fail;
45670 }
45671 {
45672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45673 }
45674 return resultobj;
45675 fail:
45676 return NULL;
45677 }
45678
45679
45680 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45681 PyObject *resultobj;
45682 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45683 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45684 wxWindow *arg3 = (wxWindow *) 0 ;
45685 bool result;
45686 PyObject * obj0 = 0 ;
45687 PyObject * obj1 = 0 ;
45688 PyObject * obj2 = 0 ;
45689 char *kwnames[] = {
45690 (char *) "self",(char *) "constraints",(char *) "win", NULL
45691 };
45692
45693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45695 if (SWIG_arg_fail(1)) SWIG_fail;
45696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45697 if (SWIG_arg_fail(2)) SWIG_fail;
45698 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45699 if (SWIG_arg_fail(3)) SWIG_fail;
45700 {
45701 PyThreadState* __tstate = wxPyBeginAllowThreads();
45702 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45703
45704 wxPyEndAllowThreads(__tstate);
45705 if (PyErr_Occurred()) SWIG_fail;
45706 }
45707 {
45708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45709 }
45710 return resultobj;
45711 fail:
45712 return NULL;
45713 }
45714
45715
45716 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45717 PyObject *resultobj;
45718 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45719 wxEdge arg2 ;
45720 wxWindow *arg3 = (wxWindow *) 0 ;
45721 wxWindow *arg4 = (wxWindow *) 0 ;
45722 int result;
45723 PyObject * obj0 = 0 ;
45724 PyObject * obj1 = 0 ;
45725 PyObject * obj2 = 0 ;
45726 PyObject * obj3 = 0 ;
45727 char *kwnames[] = {
45728 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45729 };
45730
45731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45733 if (SWIG_arg_fail(1)) SWIG_fail;
45734 {
45735 arg2 = (wxEdge)(SWIG_As_int(obj1));
45736 if (SWIG_arg_fail(2)) SWIG_fail;
45737 }
45738 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45739 if (SWIG_arg_fail(3)) SWIG_fail;
45740 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45741 if (SWIG_arg_fail(4)) SWIG_fail;
45742 {
45743 PyThreadState* __tstate = wxPyBeginAllowThreads();
45744 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45745
45746 wxPyEndAllowThreads(__tstate);
45747 if (PyErr_Occurred()) SWIG_fail;
45748 }
45749 {
45750 resultobj = SWIG_From_int((int)(result));
45751 }
45752 return resultobj;
45753 fail:
45754 return NULL;
45755 }
45756
45757
45758 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45759 PyObject *obj;
45760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45761 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45762 Py_INCREF(obj);
45763 return Py_BuildValue((char *)"");
45764 }
45765 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45766 PyObject *resultobj;
45767 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45768 wxIndividualLayoutConstraint *result;
45769 PyObject * obj0 = 0 ;
45770 char *kwnames[] = {
45771 (char *) "self", NULL
45772 };
45773
45774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45776 if (SWIG_arg_fail(1)) SWIG_fail;
45777 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45778
45779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45780 return resultobj;
45781 fail:
45782 return NULL;
45783 }
45784
45785
45786 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45787 PyObject *resultobj;
45788 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45789 wxIndividualLayoutConstraint *result;
45790 PyObject * obj0 = 0 ;
45791 char *kwnames[] = {
45792 (char *) "self", NULL
45793 };
45794
45795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45797 if (SWIG_arg_fail(1)) SWIG_fail;
45798 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45799
45800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45801 return resultobj;
45802 fail:
45803 return NULL;
45804 }
45805
45806
45807 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45808 PyObject *resultobj;
45809 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45810 wxIndividualLayoutConstraint *result;
45811 PyObject * obj0 = 0 ;
45812 char *kwnames[] = {
45813 (char *) "self", NULL
45814 };
45815
45816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45818 if (SWIG_arg_fail(1)) SWIG_fail;
45819 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45820
45821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45822 return resultobj;
45823 fail:
45824 return NULL;
45825 }
45826
45827
45828 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45829 PyObject *resultobj;
45830 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45831 wxIndividualLayoutConstraint *result;
45832 PyObject * obj0 = 0 ;
45833 char *kwnames[] = {
45834 (char *) "self", NULL
45835 };
45836
45837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45839 if (SWIG_arg_fail(1)) SWIG_fail;
45840 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45841
45842 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45843 return resultobj;
45844 fail:
45845 return NULL;
45846 }
45847
45848
45849 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45850 PyObject *resultobj;
45851 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45852 wxIndividualLayoutConstraint *result;
45853 PyObject * obj0 = 0 ;
45854 char *kwnames[] = {
45855 (char *) "self", NULL
45856 };
45857
45858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45860 if (SWIG_arg_fail(1)) SWIG_fail;
45861 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45862
45863 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45864 return resultobj;
45865 fail:
45866 return NULL;
45867 }
45868
45869
45870 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45871 PyObject *resultobj;
45872 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45873 wxIndividualLayoutConstraint *result;
45874 PyObject * obj0 = 0 ;
45875 char *kwnames[] = {
45876 (char *) "self", NULL
45877 };
45878
45879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45881 if (SWIG_arg_fail(1)) SWIG_fail;
45882 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45883
45884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45885 return resultobj;
45886 fail:
45887 return NULL;
45888 }
45889
45890
45891 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45892 PyObject *resultobj;
45893 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45894 wxIndividualLayoutConstraint *result;
45895 PyObject * obj0 = 0 ;
45896 char *kwnames[] = {
45897 (char *) "self", NULL
45898 };
45899
45900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45902 if (SWIG_arg_fail(1)) SWIG_fail;
45903 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45904
45905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45906 return resultobj;
45907 fail:
45908 return NULL;
45909 }
45910
45911
45912 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45913 PyObject *resultobj;
45914 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45915 wxIndividualLayoutConstraint *result;
45916 PyObject * obj0 = 0 ;
45917 char *kwnames[] = {
45918 (char *) "self", NULL
45919 };
45920
45921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45923 if (SWIG_arg_fail(1)) SWIG_fail;
45924 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45925
45926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45927 return resultobj;
45928 fail:
45929 return NULL;
45930 }
45931
45932
45933 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45934 PyObject *resultobj;
45935 wxLayoutConstraints *result;
45936 char *kwnames[] = {
45937 NULL
45938 };
45939
45940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45941 {
45942 PyThreadState* __tstate = wxPyBeginAllowThreads();
45943 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45944
45945 wxPyEndAllowThreads(__tstate);
45946 if (PyErr_Occurred()) SWIG_fail;
45947 }
45948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45949 return resultobj;
45950 fail:
45951 return NULL;
45952 }
45953
45954
45955 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45956 PyObject *resultobj;
45957 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45958 wxWindow *arg2 = (wxWindow *) 0 ;
45959 int *arg3 = (int *) 0 ;
45960 bool result;
45961 int temp3 ;
45962 int res3 = 0 ;
45963 PyObject * obj0 = 0 ;
45964 PyObject * obj1 = 0 ;
45965 char *kwnames[] = {
45966 (char *) "self",(char *) "win", NULL
45967 };
45968
45969 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45972 if (SWIG_arg_fail(1)) SWIG_fail;
45973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45974 if (SWIG_arg_fail(2)) SWIG_fail;
45975 {
45976 PyThreadState* __tstate = wxPyBeginAllowThreads();
45977 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45978
45979 wxPyEndAllowThreads(__tstate);
45980 if (PyErr_Occurred()) SWIG_fail;
45981 }
45982 {
45983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45984 }
45985 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45986 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45987 return resultobj;
45988 fail:
45989 return NULL;
45990 }
45991
45992
45993 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45994 PyObject *resultobj;
45995 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45996 bool result;
45997 PyObject * obj0 = 0 ;
45998 char *kwnames[] = {
45999 (char *) "self", NULL
46000 };
46001
46002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
46003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46004 if (SWIG_arg_fail(1)) SWIG_fail;
46005 {
46006 PyThreadState* __tstate = wxPyBeginAllowThreads();
46007 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
46008
46009 wxPyEndAllowThreads(__tstate);
46010 if (PyErr_Occurred()) SWIG_fail;
46011 }
46012 {
46013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46014 }
46015 return resultobj;
46016 fail:
46017 return NULL;
46018 }
46019
46020
46021 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
46022 PyObject *obj;
46023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46024 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
46025 Py_INCREF(obj);
46026 return Py_BuildValue((char *)"");
46027 }
46028 static PyMethodDef SwigMethods[] = {
46029 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
46030 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
46031 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
46034 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
46055 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
46068 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
46083 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46137 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46165 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46184 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46186 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46194 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46195 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46207 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46219 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46223 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46229 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46239 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46249 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46252 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46259 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46267 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46275 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46358 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46360 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46362 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46364 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46366 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46368 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46370 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46372 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46374 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46376 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46378 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46380 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46382 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46396 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46414 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46417 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46420 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46432 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46437 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46443 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46449 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46512 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46519 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46555 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46565 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46571 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46573 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46575 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46578 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46582 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46585 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46588 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46590 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46595 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
46603 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
46607 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
46610 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
46612 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
46616 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
46633 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
46635 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46638 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46640 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46644 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46648 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46659 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46662 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46665 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46669 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46676 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46681 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46686 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46690 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46713 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46723 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46733 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46735 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46738 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46743 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46751 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46753 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46754 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46755 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
46756 { (char *)"delete_EventLoopActivator", (PyCFunction) _wrap_delete_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
46757 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
46758 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46760 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46762 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46764 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46765 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46766 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46768 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46769 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46770 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46772 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46774 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46776 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46778 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46779 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46780 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46783 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46786 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46788 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46792 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46794 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46806 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46810 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46812 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46813 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46815 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46816 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46829 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46830 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46831 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46833 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46839 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46841 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46845 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46847 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46849 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46851 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46854 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46856 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46858 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46859 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46864 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46869 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46879 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46883 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46884 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46886 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46890 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46892 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46903 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46905 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46906 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46907 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46908 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46909 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46910 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46911 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46913 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46914 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46915 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46916 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46917 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46920 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46923 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46926 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46927 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46929 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46932 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46933 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46938 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46941 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46945 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46950 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46952 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46954 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46962 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46963 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46964 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46970 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46972 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46975 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46976 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46982 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46984 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46987 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46991 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46992 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46994 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47000 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47003 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
47004 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
47006 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47007 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
47009 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47011 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47013 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47029 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
47035 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
47038 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47040 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47041 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47044 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47046 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47059 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47063 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
47064 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47065 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47071 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
47073 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47078 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47081 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
47093 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47103 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47135 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47137 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47141 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47145 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47155 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47156 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47157 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47158 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47159 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47160 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47164 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47165 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47175 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47203 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47206 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47209 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47211 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47212 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47214 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47216 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47217 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47218 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47219 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47220 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47221 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47222 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47224 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47225 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47226 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47227 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47230 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47233 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47236 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47237 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47238 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47239 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47240 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47241 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47243 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47244 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47246 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47252 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47253 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47254 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47262 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47264 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47265 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47266 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47267 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47268 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47269 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47270 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47271 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47272 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47273 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47274 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47275 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47276 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47277 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47278 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47279 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47280 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47281 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47282 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47283 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47284 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47285 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47286 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47287 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47288 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47289 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47290 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47291 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47292 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47293 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47294 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47295 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47296 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47297 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47298 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47299 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47300 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47301 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47302 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47303 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47304 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47305 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47306 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47307 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47308 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47309 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47310 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47311 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47312 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47313 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47314 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47315 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47316 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47317 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47318 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47319 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47320 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47321 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47322 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47323 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47324 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47325 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47326 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47327 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47328 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47329 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47330 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47331 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47332 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47333 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47334 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47335 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47336 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47337 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47338 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47339 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47340 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47341 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47342 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47343 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47344 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47345 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47346 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47347 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47348 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47349 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47350 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47351 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47352 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47353 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47354 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47355 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47356 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47357 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47358 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47359 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47360 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47361 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47362 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47363 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47364 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47365 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47366 { NULL, NULL, 0, NULL }
47367 };
47368
47369
47370 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47371
47372 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47373 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47374 }
47375 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47376 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47377 }
47378 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47379 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47380 }
47381 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47382 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47383 }
47384 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47385 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47386 }
47387 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47388 return (void *)((wxSizer *) ((wxGridSizer *) x));
47389 }
47390 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47391 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47392 }
47393 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47394 return (void *)((wxSizer *) ((wxPySizer *) x));
47395 }
47396 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47397 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47398 }
47399 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47400 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47401 }
47402 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47403 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47404 }
47405 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47406 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47407 }
47408 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47409 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47410 }
47411 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47412 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47413 }
47414 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47415 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47416 }
47417 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47418 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47419 }
47420 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47421 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47422 }
47423 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47424 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47425 }
47426 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47427 return (void *)((wxEvent *) ((wxPyEvent *) x));
47428 }
47429 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47430 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47431 }
47432 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47433 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47434 }
47435 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47436 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47437 }
47438 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47439 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47440 }
47441 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47442 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47443 }
47444 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47445 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47446 }
47447 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47448 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47449 }
47450 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47451 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47452 }
47453 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47454 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47455 }
47456 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47457 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47458 }
47459 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47460 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47461 }
47462 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47463 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47464 }
47465 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47466 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47467 }
47468 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47469 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47470 }
47471 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47472 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47473 }
47474 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47475 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47476 }
47477 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47478 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47479 }
47480 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47481 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47482 }
47483 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47484 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47485 }
47486 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47487 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47488 }
47489 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47490 return (void *)((wxEvent *) ((wxShowEvent *) x));
47491 }
47492 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47493 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47494 }
47495 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47496 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47497 }
47498 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47499 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47500 }
47501 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47502 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47503 }
47504 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47505 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47506 }
47507 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47508 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47509 }
47510 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47511 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47512 }
47513 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47514 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47515 }
47516 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47517 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47518 }
47519 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47520 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47521 }
47522 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47523 return (void *)((wxControl *) ((wxControlWithItems *) x));
47524 }
47525 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47526 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47527 }
47528 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47529 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47530 }
47531 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47532 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47533 }
47534 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47535 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47536 }
47537 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47538 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47539 }
47540 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47541 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47542 }
47543 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47544 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47545 }
47546 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47547 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47548 }
47549 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47550 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47551 }
47552 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47553 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47554 }
47555 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47556 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47557 }
47558 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47559 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47560 }
47561 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47562 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47563 }
47564 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47565 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47566 }
47567 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47568 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47569 }
47570 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47571 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47572 }
47573 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47574 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47575 }
47576 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47577 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47578 }
47579 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47580 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47581 }
47582 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47583 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47584 }
47585 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47586 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47587 }
47588 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47589 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47590 }
47591 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47592 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47593 }
47594 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47595 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
47596 }
47597 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
47598 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
47599 }
47600 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
47601 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
47602 }
47603 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
47604 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
47605 }
47606 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
47607 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
47608 }
47609 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
47610 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
47611 }
47612 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
47613 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
47614 }
47615 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
47616 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
47617 }
47618 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
47619 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
47620 }
47621 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
47622 return (void *)((wxObject *) ((wxSizerItem *) x));
47623 }
47624 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
47625 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
47626 }
47627 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
47628 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
47629 }
47630 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
47631 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
47632 }
47633 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
47634 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
47635 }
47636 static void *_p_wxSizerTo_p_wxObject(void *x) {
47637 return (void *)((wxObject *) ((wxSizer *) x));
47638 }
47639 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
47640 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47641 }
47642 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47643 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47644 }
47645 static void *_p_wxEventTo_p_wxObject(void *x) {
47646 return (void *)((wxObject *) ((wxEvent *) x));
47647 }
47648 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47649 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47650 }
47651 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47652 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47653 }
47654 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47655 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47656 }
47657 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47658 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47659 }
47660 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47661 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47662 }
47663 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47664 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47665 }
47666 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47667 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47668 }
47669 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47670 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47671 }
47672 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47673 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47674 }
47675 static void *_p_wxControlTo_p_wxObject(void *x) {
47676 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47677 }
47678 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47679 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47680 }
47681 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47682 return (void *)((wxObject *) ((wxFSFile *) x));
47683 }
47684 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47685 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47686 }
47687 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47688 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47689 }
47690 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47691 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47692 }
47693 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47694 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47695 }
47696 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47697 return (void *)((wxObject *) ((wxMenuItem *) x));
47698 }
47699 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47700 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47701 }
47702 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47703 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47704 }
47705 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47706 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47707 }
47708 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47709 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47710 }
47711 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47712 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47713 }
47714 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47715 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47716 }
47717 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47718 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47719 }
47720 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47721 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47722 }
47723 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47724 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47725 }
47726 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47727 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47728 }
47729 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47730 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47731 }
47732 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47733 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47734 }
47735 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47736 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47737 }
47738 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47739 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47740 }
47741 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47742 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47743 }
47744 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47745 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47746 }
47747 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47748 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47749 }
47750 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47751 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47752 }
47753 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
47754 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
47755 }
47756 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47757 return (void *)((wxObject *) ((wxImageHandler *) x));
47758 }
47759 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47760 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47761 }
47762 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47763 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47764 }
47765 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47766 return (void *)((wxObject *) ((wxEvtHandler *) x));
47767 }
47768 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47769 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47770 }
47771 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47772 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47773 }
47774 static void *_p_wxImageTo_p_wxObject(void *x) {
47775 return (void *)((wxObject *) ((wxImage *) x));
47776 }
47777 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47778 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47779 }
47780 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47781 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47782 }
47783 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47784 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47785 }
47786 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47787 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47788 }
47789 static void *_p_wxWindowTo_p_wxObject(void *x) {
47790 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47791 }
47792 static void *_p_wxMenuTo_p_wxObject(void *x) {
47793 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47794 }
47795 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47796 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47797 }
47798 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47799 return (void *)((wxObject *) ((wxFileSystem *) x));
47800 }
47801 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47802 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47803 }
47804 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47805 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47806 }
47807 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47808 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47809 }
47810 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47811 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47812 }
47813 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47814 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47815 }
47816 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47817 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47818 }
47819 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47820 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47821 }
47822 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47823 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47824 }
47825 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47826 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47827 }
47828 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47829 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47830 }
47831 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47832 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47833 }
47834 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47835 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47836 }
47837 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47838 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47839 }
47840 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47841 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47842 }
47843 static void *_p_wxControlTo_p_wxWindow(void *x) {
47844 return (void *)((wxWindow *) ((wxControl *) x));
47845 }
47846 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47847 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47848 }
47849 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47850 return (void *)((wxWindow *) ((wxMenuBar *) x));
47851 }
47852 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47853 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47854 }
47855 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47856 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47857 }
47858 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47859 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47860 }
47861 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47862 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47863 }
47864 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47865 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47866 }
47867 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47868 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47869 }
47870 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47871 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47872 }
47873 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47874 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47875 }
47876 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47877 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47878 }
47879 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47880 return (void *)((wxValidator *) ((wxPyValidator *) x));
47881 }
47882 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}};
47883 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}};
47884 static swig_type_info _swigt__p_wxEventLoopActivator[] = {{"_p_wxEventLoopActivator", 0, "wxEventLoopActivator *", 0, 0, 0, 0},{"_p_wxEventLoopActivator", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47885 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}};
47886 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}};
47887 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}};
47888 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}};
47889 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}};
47890 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}};
47891 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}};
47892 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}};
47893 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}};
47894 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}};
47895 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}};
47896 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}};
47897 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}};
47898 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}};
47899 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}};
47900 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}};
47901 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}};
47902 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}};
47903 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}};
47904 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}};
47905 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}};
47906 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}};
47907 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}};
47908 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}};
47909 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}};
47910 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}};
47911 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}};
47912 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}};
47913 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}};
47914 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}};
47915 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}};
47916 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}};
47917 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}};
47918 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}};
47919 static swig_type_info _swigt__p_wxImage_HSVValue[] = {{"_p_wxImage_HSVValue", 0, "wxImage_HSVValue *", 0, 0, 0, 0},{"_p_wxImage_HSVValue", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47920 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}};
47921 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}};
47922 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}};
47923 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}};
47924 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}};
47925 static swig_type_info _swigt__p_wxImage_RGBValue[] = {{"_p_wxImage_RGBValue", 0, "wxImage_RGBValue *", 0, 0, 0, 0},{"_p_wxImage_RGBValue", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47926 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}};
47927 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}};
47928 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}};
47929 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}};
47930 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}};
47931 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}};
47932 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}};
47933 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}};
47934 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}};
47935 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}};
47936 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}};
47937 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}};
47938 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}};
47939 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}};
47940 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}};
47941 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}};
47942 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}};
47943 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}};
47944 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}};
47945 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}};
47946 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}};
47947 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}};
47948 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}};
47949 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}};
47950 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}};
47951 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}};
47952 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}};
47953 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}};
47954 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}};
47955 static swig_type_info _swigt__p_wxPyImageHandler[] = {{"_p_wxPyImageHandler", 0, "wxPyImageHandler *", 0, 0, 0, 0},{"_p_wxPyImageHandler", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47956 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}};
47957 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}};
47958 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}};
47959 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}};
47960 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}};
47961 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}};
47962 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}};
47963 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}};
47964 static swig_type_info _swigt__p_wxImageHandler[] = {{"_p_wxImageHandler", 0, "wxImageHandler *", 0, 0, 0, 0},{"_p_wxImageHandler", 0, 0, 0, 0, 0, 0},{"_p_wxPyImageHandler", _p_wxPyImageHandlerTo_p_wxImageHandler, 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}};
47965 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}};
47966 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}};
47967 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}};
47968 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}};
47969 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}};
47970 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}};
47971 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}};
47972 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}};
47973 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}};
47974 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}};
47975 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}};
47976 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}};
47977 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}};
47978 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}};
47979 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}};
47980 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}};
47981 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_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_wxPyImageHandler", _p_wxPyImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_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}};
47982 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}};
47983 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}};
47984 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}};
47985 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}};
47986 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}};
47987 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}};
47988 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}};
47989 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}};
47990 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}};
47991 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}};
47992 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}};
47993 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}};
47994 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}};
47995 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}};
47996 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}};
47997 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}};
47998 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47999 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}};
48000 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}};
48001 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}};
48002 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}};
48003 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}};
48004 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}};
48005 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}};
48006 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}};
48007 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}};
48008 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}};
48009 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}};
48010 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}};
48011 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}};
48012 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}};
48013 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}};
48014
48015 static swig_type_info *swig_types_initial[] = {
48016 _swigt__p_wxLayoutConstraints,
48017 _swigt__p_wxRealPoint,
48018 _swigt__p_wxEventLoopActivator,
48019 _swigt__p_wxSizerItem,
48020 _swigt__p_wxGBSizerItem,
48021 _swigt__p_wxScrollEvent,
48022 _swigt__p_wxEventLoop,
48023 _swigt__p_wxIndividualLayoutConstraint,
48024 _swigt__p_wxSizer,
48025 _swigt__p_wxBoxSizer,
48026 _swigt__p_wxStaticBoxSizer,
48027 _swigt__p_wxGridBagSizer,
48028 _swigt__p_wxAcceleratorEntry,
48029 _swigt__p_wxUpdateUIEvent,
48030 _swigt__p_wxEvent,
48031 _swigt__p_buffer,
48032 _swigt__p_wxMenu,
48033 _swigt__p_wxGridSizer,
48034 _swigt__p_wxFlexGridSizer,
48035 _swigt__p_wxInitDialogEvent,
48036 _swigt__p_wxItemContainer,
48037 _swigt__p_wxPaintEvent,
48038 _swigt__p_wxNcPaintEvent,
48039 _swigt__p_wxSysColourChangedEvent,
48040 _swigt__p_wxMouseCaptureChangedEvent,
48041 _swigt__p_wxDisplayChangedEvent,
48042 _swigt__p_wxPaletteChangedEvent,
48043 _swigt__p_wxControl,
48044 _swigt__p_wxFont,
48045 _swigt__p_wxMenuBarBase,
48046 _swigt__p_wxSetCursorEvent,
48047 _swigt__p_wxFSFile,
48048 _swigt__p_wxCaret,
48049 _swigt__ptrdiff_t,
48050 _swigt__std__ptrdiff_t,
48051 _swigt__p_wxRegion,
48052 _swigt__p_wxPoint2D,
48053 _swigt__p_wxImage_HSVValue,
48054 _swigt__p_int,
48055 _swigt__p_wxSize,
48056 _swigt__p_wxDC,
48057 _swigt__p_wxPySizer,
48058 _swigt__p_wxVisualAttributes,
48059 _swigt__p_wxImage_RGBValue,
48060 _swigt__p_wxNotifyEvent,
48061 _swigt__p_wxPyEvent,
48062 _swigt__p_wxPropagationDisabler,
48063 _swigt__p_form_ops_t,
48064 _swigt__p_wxAppTraits,
48065 _swigt__p_wxArrayString,
48066 _swigt__p_wxShowEvent,
48067 _swigt__p_wxToolTip,
48068 _swigt__p_wxMoveEvent,
48069 _swigt__p_wxSizeEvent,
48070 _swigt__p_wxActivateEvent,
48071 _swigt__p_wxIconizeEvent,
48072 _swigt__p_wxMaximizeEvent,
48073 _swigt__p_wxQueryNewPaletteEvent,
48074 _swigt__p_wxWindowCreateEvent,
48075 _swigt__p_wxIdleEvent,
48076 _swigt__p_wxDateEvent,
48077 _swigt__p_wxMenuItem,
48078 _swigt__p_wxStaticBox,
48079 _swigt__p_long,
48080 _swigt__p_wxDuplexMode,
48081 _swigt__p_wxTIFFHandler,
48082 _swigt__p_wxXPMHandler,
48083 _swigt__p_wxPNMHandler,
48084 _swigt__p_wxJPEGHandler,
48085 _swigt__p_wxPCXHandler,
48086 _swigt__p_wxGIFHandler,
48087 _swigt__p_wxPNGHandler,
48088 _swigt__p_wxANIHandler,
48089 _swigt__p_wxPyImageHandler,
48090 _swigt__p_wxMemoryFSHandler,
48091 _swigt__p_wxZipFSHandler,
48092 _swigt__p_wxInternetFSHandler,
48093 _swigt__p_wxPyFileSystemHandler,
48094 _swigt__p_wxEvtHandler,
48095 _swigt__p_wxCURHandler,
48096 _swigt__p_wxICOHandler,
48097 _swigt__p_wxBMPHandler,
48098 _swigt__p_wxImageHandler,
48099 _swigt__p_wxFileSystemHandler,
48100 _swigt__p_wxRect,
48101 _swigt__p_wxButton,
48102 _swigt__p_wxGBSpan,
48103 _swigt__p_wxPropagateOnce,
48104 _swigt__p_wxAcceleratorTable,
48105 _swigt__p_wxStdDialogButtonSizer,
48106 _swigt__p_char,
48107 _swigt__p_wxGBPosition,
48108 _swigt__p_wxImage,
48109 _swigt__p_wxFrame,
48110 _swigt__p_wxScrollWinEvent,
48111 _swigt__p_wxPaperSize,
48112 _swigt__p_wxImageHistogram,
48113 _swigt__p_wxPoint,
48114 _swigt__p_wxCursor,
48115 _swigt__p_wxObject,
48116 _swigt__p_wxInputStream,
48117 _swigt__p_wxOutputStream,
48118 _swigt__p_wxPyInputStream,
48119 _swigt__p_wxDateTime,
48120 _swigt__p_wxKeyEvent,
48121 _swigt__p_wxNavigationKeyEvent,
48122 _swigt__p_wxWindowDestroyEvent,
48123 _swigt__p_unsigned_long,
48124 _swigt__p_wxWindow,
48125 _swigt__p_wxMenuBar,
48126 _swigt__p_wxFileSystem,
48127 _swigt__p_wxBitmap,
48128 _swigt__unsigned_int,
48129 _swigt__p_unsigned_int,
48130 _swigt__p_wxMenuEvent,
48131 _swigt__p_wxContextMenuEvent,
48132 _swigt__p_unsigned_char,
48133 _swigt__p_wxMouseEvent,
48134 _swigt__p_wxEraseEvent,
48135 _swigt__p_wxCloseEvent,
48136 _swigt__p_wxPyApp,
48137 _swigt__p_wxCommandEvent,
48138 _swigt__p_wxPyCommandEvent,
48139 _swigt__p_wxPyDropTarget,
48140 _swigt__p_wxQuantize,
48141 _swigt__p_wxFocusEvent,
48142 _swigt__p_wxChildFocusEvent,
48143 _swigt__p_wxDropFilesEvent,
48144 _swigt__p_wxControlWithItems,
48145 _swigt__p_wxColour,
48146 _swigt__p_wxValidator,
48147 _swigt__p_wxPyValidator,
48148 0
48149 };
48150
48151
48152 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48153
48154 static swig_const_info swig_const_table[] = {
48155 {0, 0, 0, 0.0, 0, 0}};
48156
48157 #ifdef __cplusplus
48158 }
48159 #endif
48160
48161
48162 #ifdef __cplusplus
48163 extern "C" {
48164 #endif
48165
48166 /* Python-specific SWIG API */
48167 #define SWIG_newvarlink() SWIG_Python_newvarlink()
48168 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
48169 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
48170
48171 /* -----------------------------------------------------------------------------
48172 * global variable support code.
48173 * ----------------------------------------------------------------------------- */
48174
48175 typedef struct swig_globalvar {
48176 char *name; /* Name of global variable */
48177 PyObject *(*get_attr)(); /* Return the current value */
48178 int (*set_attr)(PyObject *); /* Set the value */
48179 struct swig_globalvar *next;
48180 } swig_globalvar;
48181
48182 typedef struct swig_varlinkobject {
48183 PyObject_HEAD
48184 swig_globalvar *vars;
48185 } swig_varlinkobject;
48186
48187 static PyObject *
48188 swig_varlink_repr(swig_varlinkobject *v) {
48189 v = v;
48190 return PyString_FromString("<Swig global variables>");
48191 }
48192
48193 static int
48194 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
48195 swig_globalvar *var;
48196 flags = flags;
48197 fprintf(fp,"Swig global variables { ");
48198 for (var = v->vars; var; var=var->next) {
48199 fprintf(fp,"%s", var->name);
48200 if (var->next) fprintf(fp,", ");
48201 }
48202 fprintf(fp," }\n");
48203 return 0;
48204 }
48205
48206 static PyObject *
48207 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
48208 swig_globalvar *var = v->vars;
48209 while (var) {
48210 if (strcmp(var->name,n) == 0) {
48211 return (*var->get_attr)();
48212 }
48213 var = var->next;
48214 }
48215 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48216 return NULL;
48217 }
48218
48219 static int
48220 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
48221 swig_globalvar *var = v->vars;
48222 while (var) {
48223 if (strcmp(var->name,n) == 0) {
48224 return (*var->set_attr)(p);
48225 }
48226 var = var->next;
48227 }
48228 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48229 return 1;
48230 }
48231
48232 static PyTypeObject varlinktype = {
48233 PyObject_HEAD_INIT(0)
48234 0, /* Number of items in variable part (ob_size) */
48235 (char *)"swigvarlink", /* Type name (tp_name) */
48236 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
48237 0, /* Itemsize (tp_itemsize) */
48238 0, /* Deallocator (tp_dealloc) */
48239 (printfunc) swig_varlink_print, /* Print (tp_print) */
48240 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
48241 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
48242 0, /* tp_compare */
48243 (reprfunc) swig_varlink_repr, /* tp_repr */
48244 0, /* tp_as_number */
48245 0, /* tp_as_sequence */
48246 0, /* tp_as_mapping */
48247 0, /* tp_hash */
48248 0, /* tp_call */
48249 0, /* tp_str */
48250 0, /* tp_getattro */
48251 0, /* tp_setattro */
48252 0, /* tp_as_buffer */
48253 0, /* tp_flags */
48254 0, /* tp_doc */
48255 #if PY_VERSION_HEX >= 0x02000000
48256 0, /* tp_traverse */
48257 0, /* tp_clear */
48258 #endif
48259 #if PY_VERSION_HEX >= 0x02010000
48260 0, /* tp_richcompare */
48261 0, /* tp_weaklistoffset */
48262 #endif
48263 #if PY_VERSION_HEX >= 0x02020000
48264 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
48265 #endif
48266 #if PY_VERSION_HEX >= 0x02030000
48267 0, /* tp_del */
48268 #endif
48269 #ifdef COUNT_ALLOCS
48270 0,0,0,0 /* tp_alloc -> tp_next */
48271 #endif
48272 };
48273
48274 /* Create a variable linking object for use later */
48275 static PyObject *
48276 SWIG_Python_newvarlink(void) {
48277 swig_varlinkobject *result = 0;
48278 result = PyMem_NEW(swig_varlinkobject,1);
48279 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
48280 result->ob_type = &varlinktype;
48281 result->vars = 0;
48282 result->ob_refcnt = 0;
48283 Py_XINCREF((PyObject *) result);
48284 return ((PyObject*) result);
48285 }
48286
48287 static void
48288 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
48289 swig_varlinkobject *v;
48290 swig_globalvar *gv;
48291 v= (swig_varlinkobject *) p;
48292 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
48293 gv->name = (char *) malloc(strlen(name)+1);
48294 strcpy(gv->name,name);
48295 gv->get_attr = get_attr;
48296 gv->set_attr = set_attr;
48297 gv->next = v->vars;
48298 v->vars = gv;
48299 }
48300
48301 /* -----------------------------------------------------------------------------
48302 * constants/methods manipulation
48303 * ----------------------------------------------------------------------------- */
48304
48305 /* Install Constants */
48306 static void
48307 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
48308 PyObject *obj = 0;
48309 size_t i;
48310 for (i = 0; constants[i].type; i++) {
48311 switch(constants[i].type) {
48312 case SWIG_PY_INT:
48313 obj = PyInt_FromLong(constants[i].lvalue);
48314 break;
48315 case SWIG_PY_FLOAT:
48316 obj = PyFloat_FromDouble(constants[i].dvalue);
48317 break;
48318 case SWIG_PY_STRING:
48319 if (constants[i].pvalue) {
48320 obj = PyString_FromString((char *) constants[i].pvalue);
48321 } else {
48322 Py_INCREF(Py_None);
48323 obj = Py_None;
48324 }
48325 break;
48326 case SWIG_PY_POINTER:
48327 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
48328 break;
48329 case SWIG_PY_BINARY:
48330 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
48331 break;
48332 default:
48333 obj = 0;
48334 break;
48335 }
48336 if (obj) {
48337 PyDict_SetItemString(d,constants[i].name,obj);
48338 Py_DECREF(obj);
48339 }
48340 }
48341 }
48342
48343 /* -----------------------------------------------------------------------------*/
48344 /* Fix SwigMethods to carry the callback ptrs when needed */
48345 /* -----------------------------------------------------------------------------*/
48346
48347 static void
48348 SWIG_Python_FixMethods(PyMethodDef *methods,
48349 swig_const_info *const_table,
48350 swig_type_info **types,
48351 swig_type_info **types_initial) {
48352 size_t i;
48353 for (i = 0; methods[i].ml_name; ++i) {
48354 char *c = methods[i].ml_doc;
48355 if (c && (c = strstr(c, "swig_ptr: "))) {
48356 int j;
48357 swig_const_info *ci = 0;
48358 char *name = c + 10;
48359 for (j = 0; const_table[j].type; j++) {
48360 if (strncmp(const_table[j].name, name,
48361 strlen(const_table[j].name)) == 0) {
48362 ci = &(const_table[j]);
48363 break;
48364 }
48365 }
48366 if (ci) {
48367 size_t shift = (ci->ptype) - types;
48368 swig_type_info *ty = types_initial[shift];
48369 size_t ldoc = (c - methods[i].ml_doc);
48370 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
48371 char *ndoc = (char*)malloc(ldoc + lptr + 10);
48372 char *buff = ndoc;
48373 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
48374 strncpy(buff, methods[i].ml_doc, ldoc);
48375 buff += ldoc;
48376 strncpy(buff, "swig_ptr: ", 10);
48377 buff += 10;
48378 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
48379 methods[i].ml_doc = ndoc;
48380 }
48381 }
48382 }
48383 }
48384
48385 /* -----------------------------------------------------------------------------*
48386 * Initialize type list
48387 * -----------------------------------------------------------------------------*/
48388
48389 #if PY_MAJOR_VERSION < 2
48390 /* PyModule_AddObject function was introduced in Python 2.0. The following function
48391 is copied out of Python/modsupport.c in python version 2.3.4 */
48392 static int
48393 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
48394 {
48395 PyObject *dict;
48396 if (!PyModule_Check(m)) {
48397 PyErr_SetString(PyExc_TypeError,
48398 "PyModule_AddObject() needs module as first arg");
48399 return -1;
48400 }
48401 if (!o) {
48402 PyErr_SetString(PyExc_TypeError,
48403 "PyModule_AddObject() needs non-NULL value");
48404 return -1;
48405 }
48406
48407 dict = PyModule_GetDict(m);
48408 if (dict == NULL) {
48409 /* Internal error -- modules must have a dict! */
48410 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
48411 PyModule_GetName(m));
48412 return -1;
48413 }
48414 if (PyDict_SetItemString(dict, name, o))
48415 return -1;
48416 Py_DECREF(o);
48417 return 0;
48418 }
48419 #endif
48420
48421 static swig_type_info **
48422 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
48423 static PyMethodDef swig_empty_runtime_method_table[] = {
48424 {
48425 NULL, NULL, 0, NULL
48426 }
48427 };/* Sentinel */
48428
48429 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
48430 swig_empty_runtime_method_table);
48431 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
48432 if (pointer && module) {
48433 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
48434 }
48435 return type_list_handle;
48436 }
48437
48438 static swig_type_info **
48439 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
48440 swig_type_info **type_pointer;
48441
48442 /* first check if module already created */
48443 type_pointer = SWIG_Python_GetTypeListHandle();
48444 if (type_pointer) {
48445 return type_pointer;
48446 } else {
48447 /* create a new module and variable */
48448 return SWIG_Python_SetTypeListHandle(type_list_handle);
48449 }
48450 }
48451
48452 #ifdef __cplusplus
48453 }
48454 #endif
48455
48456 /* -----------------------------------------------------------------------------*
48457 * Partial Init method
48458 * -----------------------------------------------------------------------------*/
48459
48460 #ifdef SWIG_LINK_RUNTIME
48461 #ifdef __cplusplus
48462 extern "C"
48463 #endif
48464 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
48465 #endif
48466
48467 #ifdef __cplusplus
48468 extern "C"
48469 #endif
48470 SWIGEXPORT(void) SWIG_init(void) {
48471 static PyObject *SWIG_globals = 0;
48472 static int typeinit = 0;
48473 PyObject *m, *d;
48474 int i;
48475 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
48476
48477 /* Fix SwigMethods to carry the callback ptrs when needed */
48478 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
48479
48480 m = Py_InitModule((char *) SWIG_name, SwigMethods);
48481 d = PyModule_GetDict(m);
48482
48483 if (!typeinit) {
48484 #ifdef SWIG_LINK_RUNTIME
48485 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
48486 #else
48487 # ifndef SWIG_STATIC_RUNTIME
48488 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
48489 # endif
48490 #endif
48491 for (i = 0; swig_types_initial[i]; i++) {
48492 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
48493 }
48494 typeinit = 1;
48495 }
48496 SWIG_InstallConstants(d,swig_const_table);
48497
48498
48499 #ifndef wxPyUSE_EXPORT
48500 // Make our API structure a CObject so other modules can import it
48501 // from this module.
48502 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
48503 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
48504 Py_XDECREF(cobj);
48505 #endif
48506
48507 {
48508 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
48512 }
48513 {
48514 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
48515 }
48516 {
48517 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
48518 }
48519 {
48520 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
48521 }
48522 {
48523 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
48524 }
48525 {
48526 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
48551 }
48552 {
48553 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
48554 }
48555 {
48556 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
48557 }
48558 {
48559 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
48560 }
48561 {
48562 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
48563 }
48564 {
48565 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
48566 }
48567 {
48568 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
48569 }
48570 {
48571 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
48572 }
48573 {
48574 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
48575 }
48576 {
48577 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
48578 }
48579 {
48580 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
48581 }
48582 {
48583 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
48584 }
48585 {
48586 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
48587 }
48588 {
48589 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
48590 }
48591 {
48592 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
48593 }
48594 {
48595 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
48596 }
48597 {
48598 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
48599 }
48600 {
48601 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
48602 }
48603 {
48604 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
48620 }
48621 {
48622 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
48623 }
48624 {
48625 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
48626 }
48627 {
48628 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
48629 }
48630 {
48631 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
48632 }
48633 {
48634 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
48635 }
48636 {
48637 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
48638 }
48639 {
48640 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
48641 }
48642 {
48643 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
48644 }
48645 {
48646 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
48647 }
48648 {
48649 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
48650 }
48651 {
48652 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
48653 }
48654 {
48655 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
48656 }
48657 {
48658 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
48659 }
48660 {
48661 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
48662 }
48663 {
48664 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
48665 }
48666 {
48667 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
48668 }
48669 {
48670 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
48671 }
48672 {
48673 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
48674 }
48675 {
48676 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
48677 }
48678 {
48679 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
48680 }
48681 {
48682 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
48683 }
48684 {
48685 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
48686 }
48687 {
48688 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
48689 }
48690 {
48691 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
48692 }
48693 {
48694 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
48695 }
48696 {
48697 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
48698 }
48699 {
48700 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
48701 }
48702 {
48703 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
48704 }
48705 {
48706 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
48707 }
48708 {
48709 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
48710 }
48711 {
48712 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
48713 }
48714 {
48715 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
48716 }
48717 {
48718 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
48719 }
48720 {
48721 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
48722 }
48723 {
48724 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
48725 }
48726 {
48727 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
48728 }
48729 {
48730 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
48731 }
48732 {
48733 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
48734 }
48735 {
48736 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48737 }
48738 {
48739 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48740 }
48741 {
48742 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48743 }
48744 {
48745 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48746 }
48747 {
48748 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48749 }
48750 {
48751 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48752 }
48753 {
48754 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48755 }
48756 {
48757 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48758 }
48759 {
48760 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48761 }
48762 {
48763 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48764 }
48765 {
48766 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48767 }
48768 {
48769 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48770 }
48771 {
48772 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int((int)(wxSIZE_FORCE)));
48773 }
48774 {
48775 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48776 }
48777 {
48778 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48779 }
48780 {
48781 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48782 }
48783 {
48784 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48785 }
48786 {
48787 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48788 }
48789 {
48790 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48791 }
48792 {
48793 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48794 }
48795 {
48796 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48797 }
48798 {
48799 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int((int)(wxID_NONE)));
48800 }
48801 {
48802 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48836 }
48837 {
48838 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48839 }
48840 {
48841 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48842 }
48843 {
48844 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48845 }
48846 {
48847 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48848 }
48849 {
48850 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48851 }
48852 {
48853 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48854 }
48855 {
48856 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48857 }
48858 {
48859 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48860 }
48861 {
48862 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48863 }
48864 {
48865 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48866 }
48867 {
48868 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48869 }
48870 {
48871 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48872 }
48873 {
48874 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48875 }
48876 {
48877 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48884 }
48885 {
48886 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48887 }
48888 {
48889 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48890 }
48891 {
48892 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48893 }
48894 {
48895 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48896 }
48897 {
48898 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48899 }
48900 {
48901 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48902 }
48903 {
48904 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48905 }
48906 {
48907 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48908 }
48909 {
48910 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48911 }
48912 {
48913 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48914 }
48915 {
48916 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48917 }
48918 {
48919 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48920 }
48921 {
48922 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48923 }
48924 {
48925 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48926 }
48927 {
48928 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48929 }
48930 {
48931 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48932 }
48933 {
48934 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48935 }
48936 {
48937 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48938 }
48939 {
48940 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48941 }
48942 {
48943 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48944 }
48945 {
48946 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48947 }
48948 {
48949 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48950 }
48951 {
48952 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48953 }
48954 {
48955 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48956 }
48957 {
48958 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48959 }
48960 {
48961 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48962 }
48963 {
48964 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48965 }
48966 {
48967 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48968 }
48969 {
48970 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48971 }
48972 {
48973 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48974 }
48975 {
48976 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48977 }
48978 {
48979 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48980 }
48981 {
48982 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48983 }
48984 {
48985 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48986 }
48987 {
48988 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48989 }
48990 {
48991 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48992 }
48993 {
48994 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48995 }
48996 {
48997 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48998 }
48999 {
49000 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
49001 }
49002 {
49003 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
49004 }
49005 {
49006 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
49007 }
49008 {
49009 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
49010 }
49011 {
49012 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
49013 }
49014 {
49015 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
49016 }
49017 {
49018 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
49019 }
49020 {
49021 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
49022 }
49023 {
49024 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
49025 }
49026 {
49027 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
49028 }
49029 {
49030 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
49031 }
49032 {
49033 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
49034 }
49035 {
49036 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
49037 }
49038 {
49039 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
49040 }
49041 {
49042 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
49043 }
49044 {
49045 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
49046 }
49047 {
49048 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
49049 }
49050 {
49051 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
49052 }
49053 {
49054 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
49055 }
49056 {
49057 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
49058 }
49059 {
49060 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
49061 }
49062 {
49063 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
49064 }
49065 {
49066 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
49067 }
49068 {
49069 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
49070 }
49071 {
49072 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
49073 }
49074 {
49075 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
49076 }
49077 {
49078 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
49079 }
49080 {
49081 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
49082 }
49083 {
49084 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
49085 }
49086 {
49087 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
49088 }
49089 {
49090 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
49091 }
49092 {
49093 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
49094 }
49095 {
49096 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
49097 }
49098 {
49099 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
49100 }
49101 {
49102 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
49103 }
49104 {
49105 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
49106 }
49107 {
49108 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
49109 }
49110 {
49111 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
49112 }
49113 {
49114 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
49115 }
49116 {
49117 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
49118 }
49119 {
49120 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
49121 }
49122 {
49123 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
49124 }
49125 {
49126 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
49127 }
49128 {
49129 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
49130 }
49131 {
49132 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
49133 }
49134 {
49135 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
49136 }
49137 {
49138 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
49139 }
49140 {
49141 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
49142 }
49143 {
49144 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
49145 }
49146 {
49147 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
49148 }
49149 {
49150 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
49151 }
49152 {
49153 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
49154 }
49155 {
49156 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
49157 }
49158 {
49159 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
49160 }
49161 {
49162 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
49163 }
49164 {
49165 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
49166 }
49167 {
49168 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
49169 }
49170 {
49171 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
49172 }
49173 {
49174 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
49175 }
49176 {
49177 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
49178 }
49179 {
49180 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
49181 }
49182 {
49183 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
49184 }
49185 {
49186 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
49187 }
49188 {
49189 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
49190 }
49191 {
49192 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
49193 }
49194 {
49195 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
49196 }
49197 {
49198 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
49199 }
49200 {
49201 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
49202 }
49203 {
49204 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
49205 }
49206 {
49207 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
49208 }
49209 {
49210 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
49211 }
49212 {
49213 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
49214 }
49215 {
49216 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
49217 }
49218 {
49219 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
49220 }
49221 {
49222 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
49223 }
49224 {
49225 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
49226 }
49227 {
49228 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
49229 }
49230 {
49231 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
49232 }
49233 {
49234 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
49235 }
49236 {
49237 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
49238 }
49239 {
49240 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
49241 }
49242 {
49243 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
49244 }
49245 {
49246 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
49250 }
49251 {
49252 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
49253 }
49254 {
49255 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
49256 }
49257 {
49258 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
49259 }
49260 {
49261 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
49262 }
49263 {
49264 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
49265 }
49266 {
49267 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
49268 }
49269 {
49270 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
49271 }
49272 {
49273 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
49274 }
49275 {
49276 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
49277 }
49278 {
49279 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
49280 }
49281 {
49282 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
49283 }
49284 {
49285 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
49286 }
49287 {
49288 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
49289 }
49290 {
49291 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
49292 }
49293 {
49294 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
49295 }
49296 {
49297 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
49298 }
49299 {
49300 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
49301 }
49302 {
49303 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
49304 }
49305 {
49306 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
49307 }
49308 {
49309 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
49310 }
49311 {
49312 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
49313 }
49314 {
49315 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
49316 }
49317 {
49318 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
49319 }
49320 {
49321 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
49322 }
49323 {
49324 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
49325 }
49326 {
49327 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
49328 }
49329 {
49330 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
49331 }
49332 {
49333 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
49334 }
49335 {
49336 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
49337 }
49338 {
49339 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
49340 }
49341 {
49342 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
49343 }
49344 {
49345 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
49346 }
49347 {
49348 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
49349 }
49350 {
49351 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
49352 }
49353 {
49354 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
49355 }
49356 {
49357 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
49358 }
49359 {
49360 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
49361 }
49362 {
49363 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
49364 }
49365 {
49366 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
49367 }
49368 {
49369 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
49370 }
49371 {
49372 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
49373 }
49374 {
49375 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
49376 }
49377 {
49378 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
49379 }
49380 {
49381 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
49382 }
49383 {
49384 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
49385 }
49386 {
49387 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
49388 }
49389 {
49390 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
49391 }
49392 {
49393 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
49394 }
49395 {
49396 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
49397 }
49398 {
49399 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
49400 }
49401 {
49402 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
49403 }
49404 {
49405 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
49406 }
49407 {
49408 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
49409 }
49410 {
49411 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
49412 }
49413 {
49414 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
49415 }
49416 {
49417 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
49418 }
49419 {
49420 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
49421 }
49422 {
49423 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
49424 }
49425 {
49426 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
49427 }
49428 {
49429 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
49430 }
49431 {
49432 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
49433 }
49434 {
49435 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
49436 }
49437 {
49438 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
49439 }
49440 {
49441 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
49442 }
49443 {
49444 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
49445 }
49446 {
49447 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
49448 }
49449 {
49450 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
49451 }
49452 {
49453 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
49460 }
49461 {
49462 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
49463 }
49464 {
49465 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
49466 }
49467 {
49468 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
49469 }
49470 {
49471 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
49472 }
49473 {
49474 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
49475 }
49476 {
49477 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
49478 }
49479 {
49480 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
49481 }
49482 {
49483 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
49484 }
49485 {
49486 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
49487 }
49488 {
49489 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
49490 }
49491 {
49492 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
49514 }
49515 {
49516 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
49517 }
49518 {
49519 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
49520 }
49521 {
49522 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
49529 }
49530 {
49531 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
49532 }
49533 {
49534 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
49535 }
49536 {
49537 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
49538 }
49539 {
49540 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
49541 }
49542 {
49543 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
49544 }
49545 {
49546 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
49547 }
49548 {
49549 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
49550 }
49551 {
49552 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
49553 }
49554 {
49555 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
49556 }
49557 {
49558 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
49559 }
49560 {
49561 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
49562 }
49563 {
49564 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
49565 }
49566 {
49567 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
49568 }
49569 {
49570 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
49571 }
49572 {
49573 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
49574 }
49575 {
49576 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
49577 }
49578 {
49579 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
49580 }
49581 {
49582 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
49583 }
49584 {
49585 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
49586 }
49587 {
49588 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
49589 }
49590 {
49591 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
49595 }
49596 {
49597 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
49598 }
49599 {
49600 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
49601 }
49602 {
49603 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
49604 }
49605 {
49606 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
49607 }
49608 {
49609 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
49610 }
49611 {
49612 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
49613 }
49614 {
49615 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
49616 }
49617 {
49618 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
49619 }
49620 {
49621 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
49622 }
49623 {
49624 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
49625 }
49626 {
49627 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
49628 }
49629 {
49630 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
49631 }
49632 {
49633 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
49634 }
49635 {
49636 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
49637 }
49638 {
49639 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
49640 }
49641 {
49642 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
49643 }
49644 {
49645 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
49646 }
49647 {
49648 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
49649 }
49650 {
49651 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
49652 }
49653 {
49654 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
49655 }
49656 {
49657 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
49658 }
49659 {
49660 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
49661 }
49662 {
49663 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
49664 }
49665 {
49666 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
49667 }
49668 {
49669 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
49670 }
49671 {
49672 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
49673 }
49674 {
49675 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
49676 }
49677 {
49678 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
49679 }
49680 {
49681 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
49682 }
49683 {
49684 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
49685 }
49686 {
49687 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
49688 }
49689 {
49690 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
49691 }
49692 {
49693 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
49694 }
49695 {
49696 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
49697 }
49698 {
49699 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
49700 }
49701 {
49702 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
49703 }
49704 {
49705 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
49706 }
49707 {
49708 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
49709 }
49710 {
49711 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
49712 }
49713 {
49714 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
49715 }
49716 {
49717 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
49718 }
49719 {
49720 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
49721 }
49722 {
49723 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
49724 }
49725 {
49726 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
49727 }
49728 {
49729 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
49730 }
49731 {
49732 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
49733 }
49734 {
49735 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
49736 }
49737 {
49738 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
49739 }
49740 {
49741 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
49742 }
49743 {
49744 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
49745 }
49746 {
49747 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49748 }
49749 {
49750 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49751 }
49752 {
49753 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49754 }
49755 {
49756 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49757 }
49758 {
49759 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49760 }
49761 {
49762 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49763 }
49764 {
49765 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49766 }
49767 {
49768 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49769 }
49770 {
49771 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49772 }
49773 {
49774 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49775 }
49776 {
49777 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49778 }
49779 {
49780 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49781 }
49782 {
49783 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49784 }
49785 {
49786 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49787 }
49788 {
49789 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49790 }
49791 {
49792 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49793 }
49794 {
49795 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49796 }
49797 {
49798 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49799 }
49800 {
49801 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49802 }
49803 {
49804 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49805 }
49806 {
49807 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49808 }
49809 {
49810 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49811 }
49812 {
49813 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49814 }
49815 {
49816 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49817 }
49818 {
49819 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49820 }
49821 {
49822 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49823 }
49824 {
49825 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49826 }
49827 {
49828 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49829 }
49830 {
49831 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49832 }
49833 {
49834 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49835 }
49836 {
49837 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49838 }
49839 {
49840 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49841 }
49842 {
49843 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49844 }
49845 {
49846 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49847 }
49848 {
49849 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49850 }
49851 {
49852 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49853 }
49854 {
49855 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49856 }
49857 {
49858 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49859 }
49860 {
49861 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49862 }
49863 {
49864 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49865 }
49866 {
49867 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49868 }
49869 {
49870 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49871 }
49872 {
49873 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49874 }
49875 {
49876 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49877 }
49878 {
49879 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49880 }
49881 {
49882 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49883 }
49884 {
49885 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49886 }
49887 {
49888 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49889 }
49890 {
49891 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49892 }
49893 {
49894 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49895 }
49896 {
49897 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49898 }
49899 {
49900 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49901 }
49902 {
49903 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49904 }
49905 {
49906 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49907 }
49908 {
49909 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49910 }
49911 {
49912 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49913 }
49914 {
49915 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49916 }
49917 {
49918 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49919 }
49920 {
49921 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49922 }
49923 {
49924 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49925 }
49926 {
49927 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49928 }
49929 {
49930 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49931 }
49932 {
49933 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49934 }
49935 {
49936 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49937 }
49938 {
49939 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49940 }
49941 {
49942 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49943 }
49944 {
49945 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49946 }
49947 {
49948 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49949 }
49950 {
49951 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49952 }
49953 {
49954 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49955 }
49956 {
49957 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49958 }
49959 {
49960 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49961 }
49962 {
49963 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49964 }
49965 {
49966 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49967 }
49968 {
49969 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49970 }
49971 {
49972 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49973 }
49974 {
49975 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49976 }
49977 {
49978 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49979 }
49980 {
49981 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49982 }
49983 {
49984 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49985 }
49986 {
49987 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49988 }
49989 {
49990 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49991 }
49992 {
49993 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49994 }
49995 {
49996 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49997 }
49998 {
49999 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
50000 }
50001 {
50002 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
50003 }
50004 {
50005 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
50006 }
50007 {
50008 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
50009 }
50010 {
50011 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
50012 }
50013 {
50014 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
50015 }
50016 {
50017 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
50018 }
50019 {
50020 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
50021 }
50022 {
50023 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
50024 }
50025 {
50026 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
50027 }
50028 {
50029 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
50030 }
50031 {
50032 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
50033 }
50034 {
50035 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
50036 }
50037 {
50038 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
50039 }
50040 {
50041 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
50042 }
50043 {
50044 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
50045 }
50046 {
50047 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
50048 }
50049 {
50050 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
50051 }
50052 {
50053 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
50054 }
50055 {
50056 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
50057 }
50058 {
50059 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
50060 }
50061 {
50062 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
50063 }
50064 {
50065 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
50066 }
50067 {
50068 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
50069 }
50070 {
50071 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
50072 }
50073 {
50074 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
50075 }
50076 {
50077 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
50078 }
50079 {
50080 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
50081 }
50082 {
50083 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD)));
50084 }
50085 {
50086 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int((int)(wxPAPER_A6)));
50087 }
50088 {
50089 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int((int)(wxPAPER_JENV_KAKU2)));
50090 }
50091 {
50092 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int((int)(wxPAPER_JENV_KAKU3)));
50093 }
50094 {
50095 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int((int)(wxPAPER_JENV_CHOU3)));
50096 }
50097 {
50098 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int((int)(wxPAPER_JENV_CHOU4)));
50099 }
50100 {
50101 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int((int)(wxPAPER_LETTER_ROTATED)));
50102 }
50103 {
50104 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int((int)(wxPAPER_A3_ROTATED)));
50105 }
50106 {
50107 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int((int)(wxPAPER_A4_ROTATED)));
50108 }
50109 {
50110 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int((int)(wxPAPER_A5_ROTATED)));
50111 }
50112 {
50113 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B4_JIS_ROTATED)));
50114 }
50115 {
50116 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B5_JIS_ROTATED)));
50117 }
50118 {
50119 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50120 }
50121 {
50122 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50123 }
50124 {
50125 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int((int)(wxPAPER_A6_ROTATED)));
50126 }
50127 {
50128 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU2_ROTATED)));
50129 }
50130 {
50131 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU3_ROTATED)));
50132 }
50133 {
50134 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU3_ROTATED)));
50135 }
50136 {
50137 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU4_ROTATED)));
50138 }
50139 {
50140 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int((int)(wxPAPER_B6_JIS)));
50141 }
50142 {
50143 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B6_JIS_ROTATED)));
50144 }
50145 {
50146 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int((int)(wxPAPER_12X11)));
50147 }
50148 {
50149 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int((int)(wxPAPER_JENV_YOU4)));
50150 }
50151 {
50152 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_YOU4_ROTATED)));
50153 }
50154 {
50155 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int((int)(wxPAPER_P16K)));
50156 }
50157 {
50158 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int((int)(wxPAPER_P32K)));
50159 }
50160 {
50161 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int((int)(wxPAPER_P32KBIG)));
50162 }
50163 {
50164 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int((int)(wxPAPER_PENV_1)));
50165 }
50166 {
50167 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int((int)(wxPAPER_PENV_2)));
50168 }
50169 {
50170 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int((int)(wxPAPER_PENV_3)));
50171 }
50172 {
50173 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int((int)(wxPAPER_PENV_4)));
50174 }
50175 {
50176 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int((int)(wxPAPER_PENV_5)));
50177 }
50178 {
50179 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int((int)(wxPAPER_PENV_6)));
50180 }
50181 {
50182 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int((int)(wxPAPER_PENV_7)));
50183 }
50184 {
50185 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int((int)(wxPAPER_PENV_8)));
50186 }
50187 {
50188 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int((int)(wxPAPER_PENV_9)));
50189 }
50190 {
50191 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int((int)(wxPAPER_PENV_10)));
50192 }
50193 {
50194 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int((int)(wxPAPER_P16K_ROTATED)));
50195 }
50196 {
50197 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int((int)(wxPAPER_P32K_ROTATED)));
50198 }
50199 {
50200 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int((int)(wxPAPER_P32KBIG_ROTATED)));
50201 }
50202 {
50203 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_1_ROTATED)));
50204 }
50205 {
50206 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_2_ROTATED)));
50207 }
50208 {
50209 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_3_ROTATED)));
50210 }
50211 {
50212 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_4_ROTATED)));
50213 }
50214 {
50215 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_5_ROTATED)));
50216 }
50217 {
50218 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_6_ROTATED)));
50219 }
50220 {
50221 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_7_ROTATED)));
50222 }
50223 {
50224 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_8_ROTATED)));
50225 }
50226 {
50227 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_9_ROTATED)));
50228 }
50229 {
50230 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_10_ROTATED)));
50231 }
50232 {
50233 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
50234 }
50235 {
50236 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
50237 }
50238 {
50239 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
50240 }
50241 {
50242 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
50243 }
50244 {
50245 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
50246 }
50247 {
50248 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
50249 }
50250 {
50251 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
50252 }
50253 {
50254 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
50255 }
50256 {
50257 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
50258 }
50259 {
50260 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
50261 }
50262 {
50263 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
50264 }
50265 {
50266 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
50267 }
50268 {
50269 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
50270 }
50271 {
50272 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
50273 }
50274 {
50275 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
50276 }
50277 {
50278 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
50279 }
50280 {
50281 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
50282 }
50283 {
50284 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
50285 }
50286 {
50287 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
50288 }
50289 {
50290 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
50291 }
50292 {
50293 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
50294 }
50295 {
50296 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
50297 }
50298 {
50299 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
50300 }
50301 {
50302 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
50303 }
50304 {
50305 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
50306 }
50307 {
50308 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
50309 }
50310 {
50311 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
50312 }
50313 {
50314 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int((int)(wxMOD_ALTGR)));
50315 }
50316 {
50317 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
50318 }
50319 {
50320 PyDict_SetItemString(d,"MOD_META", SWIG_From_int((int)(wxMOD_META)));
50321 }
50322 {
50323 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
50324 }
50325 {
50326 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int((int)(wxMOD_CMD)));
50327 }
50328 {
50329 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int((int)(wxMOD_ALL)));
50330 }
50331 {
50332 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
50333 }
50334 {
50335 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
50336 }
50337 {
50338 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
50339 }
50340 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
50341 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
50342 {
50343 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
50344 }
50345 {
50346 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
50347 }
50348 {
50349 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
50350 }
50351 {
50352 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
50353 }
50354 {
50355 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
50356 }
50357 {
50358 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
50359 }
50360 {
50361 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
50362 }
50363 {
50364 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
50365 }
50366 {
50367 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
50368 }
50369 {
50370 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
50371 }
50372 {
50373 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
50374 }
50375 {
50376 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
50377 }
50378 {
50379 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
50380 }
50381 {
50382 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
50383 }
50384 {
50385 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
50386 }
50387 {
50388 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
50389 }
50390 {
50391 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
50392 }
50393 {
50394 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
50395 }
50396 {
50397 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
50398 }
50399 {
50400 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
50401 }
50402 {
50403 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
50404 }
50405 {
50406 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
50407 }
50408 {
50409 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
50410 }
50411 {
50412 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
50413 }
50414 {
50415 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
50416 }
50417 {
50418 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
50419 }
50420 {
50421 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
50422 }
50423 {
50424 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
50425 }
50426 {
50427 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
50428 }
50429 {
50430 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
50431 }
50432 {
50433 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
50434 }
50435 {
50436 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
50437 }
50438 {
50439 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
50440 }
50441 {
50442 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
50443 }
50444 {
50445 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
50446 }
50447 {
50448 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
50449 }
50450 {
50451 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
50452 }
50453 {
50454 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
50455 }
50456 {
50457 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
50458 }
50459 {
50460 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
50461 }
50462 {
50463 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
50464 }
50465 {
50466 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
50467 }
50468 {
50469 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
50470 }
50471 {
50472 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
50473 }
50474 {
50475 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
50476 }
50477 {
50478 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
50479 }
50480 {
50481 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
50482 }
50483 {
50484 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
50485 }
50486 {
50487 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
50488 }
50489 {
50490 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
50491 }
50492 {
50493 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
50494 }
50495 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
50496 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
50497 {
50498 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
50499 }
50500 {
50501 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
50502 }
50503 {
50504 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
50505 }
50506
50507 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
50508
50509
50510 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
50511
50512 {
50513 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
50514 }
50515 {
50516 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
50517 }
50518 {
50519 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
50520 }
50521 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
50522 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
50523 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
50524 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
50525 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
50526 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
50527 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
50528 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
50529 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
50530 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
50531 {
50532 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
50533 }
50534 {
50535 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
50536 }
50537 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
50538 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
50539 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
50540 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
50541 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
50542 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
50543 {
50544 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
50545 }
50546 {
50547 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
50548 }
50549 {
50550 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
50551 }
50552 {
50553 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
50554 }
50555 {
50556 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
50557 }
50558 {
50559 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
50560 }
50561 {
50562 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
50563 }
50564 {
50565 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
50566 }
50567 {
50568 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
50569 }
50570 {
50571 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
50572 }
50573 {
50574 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
50575 }
50576 {
50577 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
50578 }
50579 {
50580 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
50581 }
50582 {
50583 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
50584 }
50585 {
50586 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
50587 }
50588 {
50589 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
50590 }
50591 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
50592 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
50593 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
50594 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
50595 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
50596 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
50597 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
50598 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
50599 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
50600 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
50601 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
50602 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
50603 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
50604 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
50605 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
50606 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
50607 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
50608 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
50609 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
50610 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
50611 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
50612 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
50613 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
50614 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
50615 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
50616 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
50617 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
50618 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
50619 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
50620 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
50621 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
50622 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
50623 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
50624 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
50625 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
50626 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
50627 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
50628 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
50629 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
50630 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
50631 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
50632 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
50633 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
50634 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
50635 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
50636 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
50637 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
50638 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
50639 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
50640 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
50641 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
50642 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
50643 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
50644 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
50645 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
50646 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
50647 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
50648 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
50649 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
50650 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
50651 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
50652 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
50653 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
50654 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
50655 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
50656 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
50657 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
50658 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
50659 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
50660 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
50661 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
50662 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
50663 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
50664 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
50665 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
50666 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
50667 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
50668 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
50669 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
50670 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
50671 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
50672 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
50673 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
50674 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
50675 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
50676 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
50677 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
50678 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
50679 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
50680 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
50681 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
50682 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
50683 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
50684 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
50685 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
50686 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
50687 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
50688 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
50689 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
50690 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
50691 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
50692 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
50693 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
50694 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
50695 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
50696 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
50697 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
50698 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
50699 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
50700 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
50701 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
50702 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
50703 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
50704 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
50705 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
50706 {
50707 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
50708 }
50709 {
50710 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
50711 }
50712 {
50713 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
50714 }
50715 {
50716 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
50717 }
50718 {
50719 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
50720 }
50721 {
50722 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
50723 }
50724 {
50725 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
50726 }
50727 {
50728 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
50729 }
50730 {
50731 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
50732 }
50733 {
50734 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
50735 }
50736 {
50737 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
50738 }
50739 {
50740 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
50741 }
50742 {
50743 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
50744 }
50745 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
50746 {
50747 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
50748 }
50749 {
50750 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
50751 }
50752 {
50753 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
50754 }
50755 {
50756 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
50757 }
50758 {
50759 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
50760 }
50761 {
50762 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
50763 }
50764 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
50765 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
50766 {
50767 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
50768 }
50769 {
50770 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
50771 }
50772 {
50773 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
50774 }
50775 {
50776 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
50777 }
50778 {
50779 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
50780 }
50781 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
50782 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
50783 {
50784 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
50785 }
50786 {
50787 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
50788 }
50789 {
50790 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
50791 }
50792 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
50793 {
50794 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
50795 }
50796 {
50797 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
50798 }
50799 {
50800 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
50801 }
50802 {
50803 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
50804 }
50805 {
50806 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
50807 }
50808 {
50809 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
50810 }
50811 {
50812 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
50813 }
50814 {
50815 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
50816 }
50817 {
50818 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
50819 }
50820 {
50821 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
50822 }
50823 {
50824 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
50825 }
50826 {
50827 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
50828 }
50829 {
50830 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
50831 }
50832 {
50833 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
50834 }
50835 {
50836 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
50837 }
50838 {
50839 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
50840 }
50841 {
50842 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
50843 }
50844 {
50845 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
50846 }
50847 {
50848 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
50849 }
50850
50851 // Initialize threading, some globals and such
50852 __wxPyPreStart(d);
50853
50854
50855 // Although these are defined in __version__ they need to be here too so
50856 // that an assert can be done to ensure that the wxPython and the wxWindows
50857 // versions match.
50858 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
50859 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
50860 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
50861
50862 }
50863
wxWidgets (Impactor)