]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Move wxDoFloodFill to dc.cpp so that it can be 'used' without wxImage. Fixes related...
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652
1653 wxPyInstance_Check,
1654 wxPySwigInstance_Check,
1655
1656 wxPyCheckForApp
1657
1658 };
1659
1660 #endif
1661
1662
1663 #if !WXWIN_COMPATIBILITY_2_4
1664 #define wxHIDE_READONLY 0
1665 #endif
1666
1667
1668 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1669 #define SWIG_From_int PyInt_FromLong
1670 /*@@*/
1671
1672
1673 #if ! wxUSE_HOTKEY
1674 enum wxHotkeyModifier
1675 {
1676 wxMOD_NONE = 0,
1677 wxMOD_ALT = 1,
1678 wxMOD_CONTROL = 2,
1679 wxMOD_SHIFT = 4,
1680 wxMOD_WIN = 8
1681 };
1682 #define wxEVT_HOTKEY 9999
1683 #endif
1684
1685 static const wxString wxPyEmptyString(wxEmptyString);
1686 static wxString wxObject_GetClassName(wxObject *self){
1687 return self->GetClassInfo()->GetClassName();
1688 }
1689 static void wxObject_Destroy(wxObject *self){
1690 delete self;
1691 }
1692
1693 #ifndef __WXMAC__
1694 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1695 #endif
1696
1697
1698 #include <limits.h>
1699
1700
1701 SWIGINTERN int
1702 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1703 const char *errmsg)
1704 {
1705 if (value < min_value) {
1706 if (errmsg) {
1707 PyErr_Format(PyExc_OverflowError,
1708 "value %ld is less than '%s' minimum %ld",
1709 value, errmsg, min_value);
1710 }
1711 return 0;
1712 } else if (value > max_value) {
1713 if (errmsg) {
1714 PyErr_Format(PyExc_OverflowError,
1715 "value %ld is greater than '%s' maximum %ld",
1716 value, errmsg, max_value);
1717 }
1718 return 0;
1719 }
1720 return 1;
1721 }
1722
1723
1724 SWIGINTERN int
1725 SWIG_AsVal_long(PyObject* obj, long* val)
1726 {
1727 if (PyNumber_Check(obj)) {
1728 if (val) *val = PyInt_AsLong(obj);
1729 return 1;
1730 }
1731 else {
1732 SWIG_type_error("number", obj);
1733 }
1734 return 0;
1735 }
1736
1737
1738 #if INT_MAX != LONG_MAX
1739 SWIGINTERN int
1740 SWIG_AsVal_int(PyObject *obj, int *val)
1741 {
1742 const char* errmsg = val ? "int" : (char*)0;
1743 long v;
1744 if (SWIG_AsVal_long(obj, &v)) {
1745 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1746 if (val) *val = (int)(v);
1747 return 1;
1748 } else {
1749 return 0;
1750 }
1751 } else {
1752 PyErr_Clear();
1753 }
1754 if (val) {
1755 SWIG_type_error(errmsg, obj);
1756 }
1757 return 0;
1758 }
1759 #else
1760 SWIGINTERNSHORT int
1761 SWIG_AsVal_int(PyObject *obj, int *val)
1762 {
1763 return SWIG_AsVal_long(obj,(long*)val);
1764 }
1765 #endif
1766
1767
1768 SWIGINTERNSHORT int
1769 SWIG_As_int(PyObject* obj)
1770 {
1771 int v;
1772 if (!SWIG_AsVal_int(obj, &v)) {
1773 /*
1774 this is needed to make valgrind/purify happier.
1775 */
1776 memset((void*)&v, 0, sizeof(int));
1777 }
1778 return v;
1779 }
1780
1781
1782 SWIGINTERNSHORT int
1783 SWIG_Check_int(PyObject* obj)
1784 {
1785 return SWIG_AsVal_int(obj, (int*)0);
1786 }
1787
1788 static PyObject *wxSize_Get(wxSize *self){
1789 bool blocked = wxPyBeginBlockThreads();
1790 PyObject* tup = PyTuple_New(2);
1791 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1792 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1793 wxPyEndBlockThreads(blocked);
1794 return tup;
1795 }
1796
1797 SWIGINTERN int
1798 SWIG_AsVal_double(PyObject *obj, double* val)
1799 {
1800 if (PyNumber_Check(obj)) {
1801 if (val) *val = PyFloat_AsDouble(obj);
1802 return 1;
1803 }
1804 else {
1805 SWIG_type_error("number", obj);
1806 }
1807 return 0;
1808 }
1809
1810
1811 SWIGINTERNSHORT double
1812 SWIG_As_double(PyObject* obj)
1813 {
1814 double v;
1815 if (!SWIG_AsVal_double(obj, &v)) {
1816 /*
1817 this is needed to make valgrind/purify happier.
1818 */
1819 memset((void*)&v, 0, sizeof(double));
1820 }
1821 return v;
1822 }
1823
1824
1825 SWIGINTERNSHORT int
1826 SWIG_Check_double(PyObject* obj)
1827 {
1828 return SWIG_AsVal_double(obj, (double*)0);
1829 }
1830
1831
1832 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1833 #define SWIG_From_double PyFloat_FromDouble
1834 /*@@*/
1835
1836 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1837 self->x = x;
1838 self->y = y;
1839 }
1840 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1841 bool blocked = wxPyBeginBlockThreads();
1842 PyObject* tup = PyTuple_New(2);
1843 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1844 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1845 wxPyEndBlockThreads(blocked);
1846 return tup;
1847 }
1848
1849 SWIGINTERNSHORT long
1850 SWIG_As_long(PyObject* obj)
1851 {
1852 long v;
1853 if (!SWIG_AsVal_long(obj, &v)) {
1854 /*
1855 this is needed to make valgrind/purify happier.
1856 */
1857 memset((void*)&v, 0, sizeof(long));
1858 }
1859 return v;
1860 }
1861
1862
1863 SWIGINTERNSHORT int
1864 SWIG_Check_long(PyObject* obj)
1865 {
1866 return SWIG_AsVal_long(obj, (long*)0);
1867 }
1868
1869 static void wxPoint_Set(wxPoint *self,long x,long y){
1870 self->x = x;
1871 self->y = y;
1872 }
1873 static PyObject *wxPoint_Get(wxPoint *self){
1874 bool blocked = wxPyBeginBlockThreads();
1875 PyObject* tup = PyTuple_New(2);
1876 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1877 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1878 wxPyEndBlockThreads(blocked);
1879 return tup;
1880 }
1881 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1882 self->x = x;
1883 self->y = y;
1884 self->width = width;
1885 self->height = height;
1886 }
1887 static PyObject *wxRect_Get(wxRect *self){
1888 bool blocked = wxPyBeginBlockThreads();
1889 PyObject* tup = PyTuple_New(4);
1890 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1891 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1892 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1893 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1894 wxPyEndBlockThreads(blocked);
1895 return tup;
1896 }
1897
1898 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1899 wxRegion reg1(*r1);
1900 wxRegion reg2(*r2);
1901 wxRect dest(0,0,0,0);
1902 PyObject* obj;
1903
1904 reg1.Intersect(reg2);
1905 dest = reg1.GetBox();
1906
1907 if (dest != wxRect(0,0,0,0)) {
1908 bool blocked = wxPyBeginBlockThreads();
1909 wxRect* newRect = new wxRect(dest);
1910 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1911 wxPyEndBlockThreads(blocked);
1912 return obj;
1913 }
1914 Py_INCREF(Py_None);
1915 return Py_None;
1916 }
1917
1918
1919 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1920 PyObject* o2;
1921 PyObject* o3;
1922
1923 if (!target) {
1924 target = o;
1925 } else if (target == Py_None) {
1926 Py_DECREF(Py_None);
1927 target = o;
1928 } else {
1929 if (!PyTuple_Check(target)) {
1930 o2 = target;
1931 target = PyTuple_New(1);
1932 PyTuple_SetItem(target, 0, o2);
1933 }
1934 o3 = PyTuple_New(1);
1935 PyTuple_SetItem(o3, 0, o);
1936
1937 o2 = target;
1938 target = PySequence_Concat(o2, o3);
1939 Py_DECREF(o2);
1940 Py_DECREF(o3);
1941 }
1942 return target;
1943 }
1944
1945
1946 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1947 self->m_x = x;
1948 self->m_y = y;
1949 }
1950 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1951 bool blocked = wxPyBeginBlockThreads();
1952 PyObject* tup = PyTuple_New(2);
1953 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1954 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1955 wxPyEndBlockThreads(blocked);
1956 return tup;
1957 }
1958
1959 #include "wx/wxPython/pyistream.h"
1960
1961 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1962 wxInputStream* wxis = wxPyCBInputStream::create(p);
1963 if (wxis)
1964 return new wxPyInputStream(wxis);
1965 else
1966 return NULL;
1967 }
1968
1969 SWIGINTERNSHORT PyObject*
1970 SWIG_From_char(char c)
1971 {
1972 return PyString_FromStringAndSize(&c,1);
1973 }
1974
1975
1976 SWIGINTERNSHORT PyObject*
1977 SWIG_From_unsigned_SS_long(unsigned long value)
1978 {
1979 return (value > LONG_MAX) ?
1980 PyLong_FromUnsignedLong(value)
1981 : PyInt_FromLong((long)(value));
1982 }
1983
1984
1985 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1986 SWIGINTERN int
1987 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1988 {
1989 static swig_type_info* pchar_info = 0;
1990 char* vptr = 0;
1991 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1992 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1993 if (cptr) *cptr = vptr;
1994 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1995 return SWIG_OLDOBJ;
1996 } else {
1997 PyErr_Clear();
1998 if (PyString_Check(obj)) {
1999 if (cptr) {
2000 *cptr = PyString_AS_STRING(obj);
2001 if (psize) {
2002 *psize = PyString_GET_SIZE(obj) + 1;
2003 }
2004 }
2005 return SWIG_PYSTR;
2006 }
2007 }
2008 if (cptr) {
2009 SWIG_type_error("char *", obj);
2010 }
2011 return 0;
2012 }
2013
2014
2015 SWIGINTERN int
2016 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2017 {
2018 char* cptr; size_t csize;
2019 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2020 /* in C you can do:
2021
2022 char x[5] = "hello";
2023
2024 ie, assing the array using an extra '0' char.
2025 */
2026 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2027 if (csize <= size) {
2028 if (val) {
2029 if (csize) memcpy(val, cptr, csize);
2030 if (csize < size) memset(val + csize, 0, size - csize);
2031 }
2032 return 1;
2033 }
2034 }
2035 if (val) {
2036 PyErr_Format(PyExc_TypeError,
2037 "a char array of maximum size %lu is expected",
2038 (unsigned long) size);
2039 }
2040 return 0;
2041 }
2042
2043
2044 SWIGINTERN int
2045 SWIG_AsVal_char(PyObject *obj, char *val)
2046 {
2047 const char* errmsg = val ? "char" : (char*)0;
2048 long v;
2049 if (SWIG_AsVal_long(obj, &v)) {
2050 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2051 if (val) *val = (char)(v);
2052 return 1;
2053 } else {
2054 return 0;
2055 }
2056 } else {
2057 PyErr_Clear();
2058 return SWIG_AsCharArray(obj, val, 1);
2059 }
2060 }
2061
2062
2063 SWIGINTERNSHORT char
2064 SWIG_As_char(PyObject* obj)
2065 {
2066 char v;
2067 if (!SWIG_AsVal_char(obj, &v)) {
2068 /*
2069 this is needed to make valgrind/purify happier.
2070 */
2071 memset((void*)&v, 0, sizeof(char));
2072 }
2073 return v;
2074 }
2075
2076
2077 SWIGINTERNSHORT int
2078 SWIG_Check_char(PyObject* obj)
2079 {
2080 return SWIG_AsVal_char(obj, (char*)0);
2081 }
2082
2083
2084 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2085 #define SWIG_From_long PyInt_FromLong
2086 /*@@*/
2087
2088 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2089 // We use only strings for the streams, not unicode
2090 PyObject* str = PyObject_Str(obj);
2091 if (! str) {
2092 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2093 return;
2094 }
2095 self->Write(PyString_AS_STRING(str),
2096 PyString_GET_SIZE(str));
2097 Py_DECREF(str);
2098 }
2099
2100 #include "wx/wxPython/pyistream.h"
2101
2102
2103 class wxPyFileSystemHandler : public wxFileSystemHandler
2104 {
2105 public:
2106 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2107
2108 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2109 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2110 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2111 DEC_PYCALLBACK_STRING__pure(FindNext);
2112
2113 wxString GetProtocol(const wxString& location) {
2114 return wxFileSystemHandler::GetProtocol(location);
2115 }
2116
2117 wxString GetLeftLocation(const wxString& location) {
2118 return wxFileSystemHandler::GetLeftLocation(location);
2119 }
2120
2121 wxString GetAnchor(const wxString& location) {
2122 return wxFileSystemHandler::GetAnchor(location);
2123 }
2124
2125 wxString GetRightLocation(const wxString& location) {
2126 return wxFileSystemHandler::GetRightLocation(location);
2127 }
2128
2129 wxString GetMimeTypeFromExt(const wxString& location) {
2130 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2131 }
2132
2133 PYPRIVATE;
2134 };
2135
2136
2137 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2138 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2139 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2140 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2141
2142
2143 SWIGINTERN int
2144 SWIG_AsVal_bool(PyObject *obj, bool *val)
2145 {
2146 if (obj == Py_True) {
2147 if (val) *val = true;
2148 return 1;
2149 }
2150 if (obj == Py_False) {
2151 if (val) *val = false;
2152 return 1;
2153 }
2154 int res = 0;
2155 if (SWIG_AsVal_int(obj, &res)) {
2156 if (val) *val = res ? true : false;
2157 return 1;
2158 } else {
2159 PyErr_Clear();
2160 }
2161 if (val) {
2162 SWIG_type_error("bool", obj);
2163 }
2164 return 0;
2165 }
2166
2167
2168 SWIGINTERNSHORT bool
2169 SWIG_As_bool(PyObject* obj)
2170 {
2171 bool v;
2172 if (!SWIG_AsVal_bool(obj, &v)) {
2173 /*
2174 this is needed to make valgrind/purify happier.
2175 */
2176 memset((void*)&v, 0, sizeof(bool));
2177 }
2178 return v;
2179 }
2180
2181
2182 SWIGINTERNSHORT int
2183 SWIG_Check_bool(PyObject* obj)
2184 {
2185 return SWIG_AsVal_bool(obj, (bool*)0);
2186 }
2187
2188 static wxString FileSystem_URLToFileName(wxString const &url){
2189 wxFileName fname = wxFileSystem::URLToFileName(url);
2190 return fname.GetFullPath();
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2194 wxImage& image,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, image, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2200 const wxBitmap& bitmap,
2201 long type) {
2202 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2203 }
2204
2205 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2206 PyObject* data) {
2207 if (! PyString_Check(data)) {
2208 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2209 "Expected string object"));
2210 return;
2211 }
2212
2213 bool blocked = wxPyBeginBlockThreads();
2214 void* ptr = (void*)PyString_AsString(data);
2215 size_t size = PyString_Size(data);
2216 wxPyEndBlockThreads(blocked);
2217
2218 wxMemoryFSHandler::AddFile(filename, ptr, size);
2219 }
2220
2221
2222 #include "wx/wxPython/pyistream.h"
2223
2224
2225 SWIGINTERN int
2226 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2227 {
2228 long v = 0;
2229 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2230 SWIG_type_error("unsigned number", obj);
2231 }
2232 else if (val)
2233 *val = (unsigned long)v;
2234 return 1;
2235 }
2236
2237
2238 SWIGINTERNSHORT int
2239 SWIG_CheckUnsignedLongInRange(unsigned long value,
2240 unsigned long max_value,
2241 const char *errmsg)
2242 {
2243 if (value > max_value) {
2244 if (errmsg) {
2245 PyErr_Format(PyExc_OverflowError,
2246 "value %lu is greater than '%s' minimum %lu",
2247 value, errmsg, max_value);
2248 }
2249 return 0;
2250 }
2251 return 1;
2252 }
2253
2254
2255 SWIGINTERN int
2256 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2257 {
2258 const char* errmsg = val ? "unsigned char" : (char*)0;
2259 unsigned long v;
2260 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2261 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2262 if (val) *val = (unsigned char)(v);
2263 return 1;
2264 } else {
2265 return 0;
2266 }
2267 } else {
2268 PyErr_Clear();
2269 }
2270 if (val) {
2271 SWIG_type_error(errmsg, obj);
2272 }
2273 return 0;
2274 }
2275
2276
2277 SWIGINTERNSHORT unsigned char
2278 SWIG_As_unsigned_SS_char(PyObject* obj)
2279 {
2280 unsigned char v;
2281 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2282 /*
2283 this is needed to make valgrind/purify happier.
2284 */
2285 memset((void*)&v, 0, sizeof(unsigned char));
2286 }
2287 return v;
2288 }
2289
2290
2291 SWIGINTERNSHORT int
2292 SWIG_Check_unsigned_SS_char(PyObject* obj)
2293 {
2294 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2295 }
2296
2297
2298 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2299 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2300 /*@@*/
2301
2302
2303 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2304 if (width > 0 && height > 0)
2305 return new wxImage(width, height, clear);
2306 else
2307 return new wxImage;
2308 }
2309 static wxImage *new_wxImage(wxBitmap const &bitmap){
2310 return new wxImage(bitmap.ConvertToImage());
2311 }
2312 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2313 // Copy the source data so the wxImage can clean it up later
2314 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2315 if (copy == NULL) {
2316 PyErr_NoMemory();
2317 return NULL;
2318 }
2319 memcpy(copy, data, width*height*3);
2320 return new wxImage(width, height, copy, false);
2321 }
2322 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2323 // Copy the source data so the wxImage can clean it up later
2324 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2325 if (dcopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(dcopy, data, width*height*3);
2330 unsigned char* acopy = (unsigned char*)malloc(width*height);
2331 if (acopy == NULL) {
2332 PyErr_NoMemory();
2333 return NULL;
2334 }
2335 memcpy(acopy, alpha, width*height);
2336
2337 return new wxImage(width, height, dcopy, acopy, false);
2338 }
2339 static wxSize wxImage_GetSize(wxImage *self){
2340 wxSize size(self->GetWidth(), self->GetHeight());
2341 return size;
2342 }
2343 static PyObject *wxImage_GetData(wxImage *self){
2344 unsigned char* data = self->GetData();
2345 int len = self->GetWidth() * self->GetHeight() * 3;
2346 PyObject* rv;
2347 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2348 return rv;
2349 }
2350 static void wxImage_SetData(wxImage *self,PyObject *data){
2351 unsigned char* dataPtr;
2352
2353 if (! PyString_Check(data)) {
2354 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2355 "Expected string object"));
2356 return /* NULL */ ;
2357 }
2358
2359 size_t len = self->GetWidth() * self->GetHeight() * 3;
2360 dataPtr = (unsigned char*) malloc(len);
2361 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2362 self->SetData(dataPtr);
2363 // wxImage takes ownership of dataPtr...
2364 }
2365 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2366 unsigned char* data = self->GetData();
2367 int len = self->GetWidth() * self->GetHeight() * 3;
2368 PyObject* rv;
2369 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2370 return rv;
2371 }
2372 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2373 unsigned char* buffer;
2374 int size;
2375
2376 bool blocked = wxPyBeginBlockThreads();
2377 if (!PyArg_Parse(data, "t#", &buffer, &size))
2378 goto done;
2379
2380 if (size != self->GetWidth() * self->GetHeight() * 3) {
2381 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2382 goto done;
2383 }
2384 self->SetData(buffer);
2385 done:
2386 wxPyEndBlockThreads(blocked);
2387 }
2388 static PyObject *wxImage_GetAlphaData(wxImage *self){
2389 unsigned char* data = self->GetAlpha();
2390 if (! data) {
2391 RETURN_NONE();
2392 } else {
2393 int len = self->GetWidth() * self->GetHeight();
2394 PyObject* rv;
2395 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2396 return rv;
2397 }
2398 }
2399 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2400 unsigned char* dataPtr;
2401
2402 if (! PyString_Check(data)) {
2403 PyErr_SetString(PyExc_TypeError, "Expected string object");
2404 return /* NULL */ ;
2405 }
2406
2407 size_t len = self->GetWidth() * self->GetHeight();
2408 dataPtr = (unsigned char*) malloc(len);
2409 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2410 self->SetAlpha(dataPtr);
2411 // wxImage takes ownership of dataPtr...
2412 }
2413 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2414 unsigned char* data = self->GetAlpha();
2415 int len = self->GetWidth() * self->GetHeight();
2416 PyObject* rv;
2417 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2418 return rv;
2419 }
2420 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2421 unsigned char* buffer;
2422 int size;
2423
2424 bool blocked = wxPyBeginBlockThreads();
2425 if (!PyArg_Parse(data, "t#", &buffer, &size))
2426 goto done;
2427
2428 if (size != self->GetWidth() * self->GetHeight()) {
2429 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2430 goto done;
2431 }
2432 self->SetAlpha(buffer);
2433 done:
2434 wxPyEndBlockThreads(blocked);
2435 }
2436
2437 SWIGINTERNSHORT unsigned long
2438 SWIG_As_unsigned_SS_long(PyObject* obj)
2439 {
2440 unsigned long v;
2441 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2442 /*
2443 this is needed to make valgrind/purify happier.
2444 */
2445 memset((void*)&v, 0, sizeof(unsigned long));
2446 }
2447 return v;
2448 }
2449
2450
2451 SWIGINTERNSHORT int
2452 SWIG_Check_unsigned_SS_long(PyObject* obj)
2453 {
2454 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2455 }
2456
2457 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2458 wxBitmap bitmap(*self, depth);
2459 return bitmap;
2460 }
2461 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2462 wxImage mono = self->ConvertToMono( red, green, blue );
2463 wxBitmap bitmap( mono, 1 );
2464 return bitmap;
2465 }
2466 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2467 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2468 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2470 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2474 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2475 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2476 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2477 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2478 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2479 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2480 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2481
2482 #include <wx/quantize.h>
2483
2484 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2485 return wxQuantize::Quantize(src, dest,
2486 //NULL, // palette
2487 desiredNoColours,
2488 NULL, // eightBitData
2489 flags);
2490 }
2491 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2492 if (PyCallable_Check(func)) {
2493 self->Connect(id, lastId, eventType,
2494 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2495 new wxPyCallback(func));
2496 }
2497 else if (func == Py_None) {
2498 self->Disconnect(id, lastId, eventType,
2499 (wxObjectEventFunction)
2500 &wxPyCallback::EventThunker);
2501 }
2502 else {
2503 wxPyBLOCK_THREADS(
2504 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2505 }
2506 }
2507 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2508 return self->Disconnect(id, lastId, eventType,
2509 (wxObjectEventFunction)
2510 &wxPyCallback::EventThunker);
2511 }
2512 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2513 if (_self && _self != Py_None) {
2514 self->SetClientObject(new wxPyOORClientData(_self, incref));
2515 }
2516 else {
2517 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2518 if (data) {
2519 self->SetClientObject(NULL); // This will delete it too
2520 }
2521 }
2522 }
2523
2524 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2525 #if wxUSE_UNICODE
2526 return self->GetUnicodeKey();
2527 #else
2528 return 0;
2529 #endif
2530 }
2531
2532 #if UINT_MAX < LONG_MAX
2533 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2534 #define SWIG_From_unsigned_SS_int SWIG_From_long
2535 /*@@*/
2536 #else
2537 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2538 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2539 /*@@*/
2540 #endif
2541
2542
2543 #if UINT_MAX != ULONG_MAX
2544 SWIGINTERN int
2545 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2546 {
2547 const char* errmsg = val ? "unsigned int" : (char*)0;
2548 unsigned long v;
2549 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2550 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2551 if (val) *val = (unsigned int)(v);
2552 return 1;
2553 }
2554 } else {
2555 PyErr_Clear();
2556 }
2557 if (val) {
2558 SWIG_type_error(errmsg, obj);
2559 }
2560 return 0;
2561 }
2562 #else
2563 SWIGINTERNSHORT unsigned int
2564 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2565 {
2566 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2567 }
2568 #endif
2569
2570
2571 SWIGINTERNSHORT unsigned int
2572 SWIG_As_unsigned_SS_int(PyObject* obj)
2573 {
2574 unsigned int v;
2575 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2576 /*
2577 this is needed to make valgrind/purify happier.
2578 */
2579 memset((void*)&v, 0, sizeof(unsigned int));
2580 }
2581 return v;
2582 }
2583
2584
2585 SWIGINTERNSHORT int
2586 SWIG_Check_unsigned_SS_int(PyObject* obj)
2587 {
2588 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2589 }
2590
2591 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2592 self->m_size = size;
2593 }
2594 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2595 int count = self->GetNumberOfFiles();
2596 wxString* files = self->GetFiles();
2597 PyObject* list = PyList_New(count);
2598
2599 if (!list) {
2600 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2601 return NULL;
2602 }
2603
2604 for (int i=0; i<count; i++) {
2605 PyList_SetItem(list, i, wx2PyString(files[i]));
2606 }
2607 return list;
2608 }
2609
2610
2611 static wxPyApp *new_wxPyApp(){
2612 wxPythonApp = new wxPyApp();
2613 return wxPythonApp;
2614 }
2615 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2616
2617 void wxApp_CleanUp() {
2618 __wxPyCleanup();
2619 }
2620
2621
2622 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2623
2624
2625 SWIGINTERNSHORT int
2626 SWIG_AsCharPtr(PyObject *obj, char **val)
2627 {
2628 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2629 return 1;
2630 }
2631 if (val) {
2632 PyErr_Clear();
2633 SWIG_type_error("char *", obj);
2634 }
2635 return 0;
2636 }
2637
2638
2639 SWIGINTERN PyObject *
2640 SWIG_FromCharPtr(const char* cptr)
2641 {
2642 if (cptr) {
2643 size_t size = strlen(cptr);
2644 if (size > INT_MAX) {
2645 return SWIG_NewPointerObj((char*)(cptr),
2646 SWIG_TypeQuery("char *"), 0);
2647 } else {
2648 if (size != 0) {
2649 return PyString_FromStringAndSize(cptr, size);
2650 } else {
2651 return PyString_FromString(cptr);
2652 }
2653 }
2654 }
2655 Py_INCREF(Py_None);
2656 return Py_None;
2657 }
2658
2659
2660 #ifdef __WXMAC__
2661
2662 // A dummy class that raises an exception if used...
2663 class wxEventLoop
2664 {
2665 public:
2666 wxEventLoop() { wxPyRaiseNotImplemented(); }
2667 int Run() { return 0; }
2668 void Exit(int rc = 0) {}
2669 bool Pending() const { return false; }
2670 bool Dispatch() { return false; }
2671 bool IsRunning() const { return false; }
2672 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2673 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2674 };
2675
2676 #else
2677
2678 #include <wx/evtloop.h>
2679
2680 #endif
2681
2682
2683
2684 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2685 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2686 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2687 static PyObject *wxWindow_GetChildren(wxWindow *self){
2688 wxWindowList& list = self->GetChildren();
2689 return wxPy_ConvertList(&list);
2690 }
2691 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2692 #if wxUSE_HOTKEY
2693 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2694 #else
2695 return false;
2696 #endif
2697 }
2698 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2699
2700
2701
2702 return false;
2703
2704 }
2705 static long wxWindow_GetHandle(wxWindow *self){
2706 return wxPyGetWinHandle(self);
2707 }
2708 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2709 self->AssociateHandle((WXWidget)handle);
2710 }
2711
2712 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2713 return wxWindow::FindWindowById(id, parent);
2714 }
2715
2716 wxWindow* wxFindWindowByName( const wxString& name,
2717 const wxWindow *parent = NULL ) {
2718 return wxWindow::FindWindowByName(name, parent);
2719 }
2720
2721 wxWindow* wxFindWindowByLabel( const wxString& label,
2722 const wxWindow *parent = NULL ) {
2723 return wxWindow::FindWindowByLabel(label, parent);
2724 }
2725
2726
2727 #ifdef __WXMSW__
2728 #include <wx/msw/private.h> // to get wxGetWindowId
2729 #endif
2730
2731
2732 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2733 #ifdef __WXMSW__
2734 WXHWND hWnd = (WXHWND)_hWnd;
2735 long id = wxGetWindowId(hWnd);
2736 wxWindow* win = new wxWindow;
2737 parent->AddChild(win);
2738 win->SetEventHandler(win);
2739 win->SetHWND(hWnd);
2740 win->SetId(id);
2741 win->SubclassWin(hWnd);
2742 win->AdoptAttributesFromHWND();
2743 win->SetupColours();
2744 return win;
2745 #else
2746 wxPyRaiseNotImplemented();
2747 return NULL;
2748 #endif
2749 }
2750
2751
2752 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2753 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2754 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2755
2756 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2757
2758 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2759 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2760 wxMenuItemList& list = self->GetMenuItems();
2761 return wxPy_ConvertList(&list);
2762 }
2763 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2764 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2765 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2766 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2767 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2768 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2769 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2770 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2771 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2772 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2773 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2774 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2775 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2776 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2777 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2778 static const wxString wxPyControlNameStr(wxControlNameStr);
2779 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2780 if (clientData) {
2781 wxPyClientData* data = new wxPyClientData(clientData);
2782 return self->Append(item, data);
2783 } else
2784 return self->Append(item);
2785 }
2786 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2787 if (clientData) {
2788 wxPyClientData* data = new wxPyClientData(clientData);
2789 return self->Insert(item, pos, data);
2790 } else
2791 return self->Insert(item, pos);
2792 }
2793 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2794 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2795 if (data) {
2796 Py_INCREF(data->m_obj);
2797 return data->m_obj;
2798 } else {
2799 Py_INCREF(Py_None);
2800 return Py_None;
2801 }
2802 }
2803 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2804 wxPyClientData* data = new wxPyClientData(clientData);
2805 self->SetClientObject(n, data);
2806 }
2807
2808
2809 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2810 wxPyUserData* data = NULL;
2811 if ( userData ) {
2812 bool blocked = wxPyBeginBlockThreads();
2813 data = new wxPyUserData(userData);
2814 wxPyEndBlockThreads(blocked);
2815 }
2816 return new wxSizerItem(window, proportion, flag, border, data);
2817 }
2818 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2819 wxPyUserData* data = NULL;
2820 if ( userData ) {
2821 bool blocked = wxPyBeginBlockThreads();
2822 data = new wxPyUserData(userData);
2823 wxPyEndBlockThreads(blocked);
2824 }
2825 return new wxSizerItem(width, height, proportion, flag, border, data);
2826 }
2827 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2828 wxPyUserData* data = NULL;
2829 if ( userData ) {
2830 bool blocked = wxPyBeginBlockThreads();
2831 data = new wxPyUserData(userData);
2832 wxPyEndBlockThreads(blocked);
2833 }
2834 return new wxSizerItem(sizer, proportion, flag, border, data);
2835 }
2836
2837 #include <float.h>
2838 SWIGINTERN int
2839 SWIG_CheckDoubleInRange(double value, double min_value,
2840 double max_value, const char* errmsg)
2841 {
2842 if (value < min_value) {
2843 if (errmsg) {
2844 PyErr_Format(PyExc_OverflowError,
2845 "value %g is less than %s minimum %g",
2846 value, errmsg, min_value);
2847 }
2848 return 0;
2849 } else if (value > max_value) {
2850 if (errmsg) {
2851 PyErr_Format(PyExc_OverflowError,
2852 "value %g is greater than %s maximum %g",
2853 value, errmsg, max_value);
2854 }
2855 return 0;
2856 }
2857 return 1;
2858 }
2859
2860
2861 SWIGINTERN int
2862 SWIG_AsVal_float(PyObject *obj, float *val)
2863 {
2864 const char* errmsg = val ? "float" : (char*)0;
2865 double v;
2866 if (SWIG_AsVal_double(obj, &v)) {
2867 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2868 if (val) *val = (float)(v);
2869 return 1;
2870 } else {
2871 return 0;
2872 }
2873 } else {
2874 PyErr_Clear();
2875 }
2876 if (val) {
2877 SWIG_type_error(errmsg, obj);
2878 }
2879 return 0;
2880 }
2881
2882
2883 SWIGINTERNSHORT float
2884 SWIG_As_float(PyObject* obj)
2885 {
2886 float v;
2887 if (!SWIG_AsVal_float(obj, &v)) {
2888 /*
2889 this is needed to make valgrind/purify happier.
2890 */
2891 memset((void*)&v, 0, sizeof(float));
2892 }
2893 return v;
2894 }
2895
2896
2897 SWIGINTERNSHORT int
2898 SWIG_Check_float(PyObject* obj)
2899 {
2900 return SWIG_AsVal_float(obj, (float*)0);
2901 }
2902
2903
2904 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2905 #define SWIG_From_float PyFloat_FromDouble
2906 /*@@*/
2907
2908 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2909 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2910 if (data) {
2911 Py_INCREF(data->m_obj);
2912 return data->m_obj;
2913 } else {
2914 Py_INCREF(Py_None);
2915 return Py_None;
2916 }
2917 }
2918
2919 // Figure out the type of the sizer item
2920
2921 struct wxPySizerItemInfo {
2922 wxPySizerItemInfo()
2923 : window(NULL), sizer(NULL), gotSize(false),
2924 size(wxDefaultSize), gotPos(false), pos(-1)
2925 {}
2926
2927 wxWindow* window;
2928 wxSizer* sizer;
2929 bool gotSize;
2930 wxSize size;
2931 bool gotPos;
2932 int pos;
2933 };
2934
2935 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2936
2937 wxPySizerItemInfo info;
2938 wxSize size;
2939 wxSize* sizePtr = &size;
2940
2941 // Find out what the type of the item is
2942 // try wxWindow
2943 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2944 PyErr_Clear();
2945 info.window = NULL;
2946
2947 // try wxSizer
2948 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2949 PyErr_Clear();
2950 info.sizer = NULL;
2951
2952 // try wxSize or (w,h)
2953 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2954 info.size = *sizePtr;
2955 info.gotSize = true;
2956 }
2957
2958 // or a single int
2959 if (checkIdx && PyInt_Check(item)) {
2960 info.pos = PyInt_AsLong(item);
2961 info.gotPos = true;
2962 }
2963 }
2964 }
2965
2966 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2967 // no expected type, figure out what kind of error message to generate
2968 if ( !checkSize && !checkIdx )
2969 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2970 else if ( checkSize && !checkIdx )
2971 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2972 else if ( !checkSize && checkIdx)
2973 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2974 else
2975 // can this one happen?
2976 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2977 }
2978
2979 return info;
2980 }
2981
2982 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2983 if (!self->GetClientObject())
2984 self->SetClientObject(new wxPyOORClientData(_self));
2985 }
2986 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2987
2988 wxPyUserData* data = NULL;
2989 bool blocked = wxPyBeginBlockThreads();
2990 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2991 if ( userData && (info.window || info.sizer || info.gotSize) )
2992 data = new wxPyUserData(userData);
2993 wxPyEndBlockThreads(blocked);
2994
2995 // Now call the real Add method if a valid item type was found
2996 if ( info.window )
2997 return self->Add(info.window, proportion, flag, border, data);
2998 else if ( info.sizer )
2999 return self->Add(info.sizer, proportion, flag, border, data);
3000 else if (info.gotSize)
3001 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3002 proportion, flag, border, data);
3003 else
3004 return NULL;
3005 }
3006 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3007
3008 wxPyUserData* data = NULL;
3009 bool blocked = wxPyBeginBlockThreads();
3010 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3011 if ( userData && (info.window || info.sizer || info.gotSize) )
3012 data = new wxPyUserData(userData);
3013 wxPyEndBlockThreads(blocked);
3014
3015 // Now call the real Insert method if a valid item type was found
3016 if ( info.window )
3017 return self->Insert(before, info.window, proportion, flag, border, data);
3018 else if ( info.sizer )
3019 return self->Insert(before, info.sizer, proportion, flag, border, data);
3020 else if (info.gotSize)
3021 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3022 proportion, flag, border, data);
3023 else
3024 return NULL;
3025 }
3026 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3027
3028 wxPyUserData* data = NULL;
3029 bool blocked = wxPyBeginBlockThreads();
3030 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3031 if ( userData && (info.window || info.sizer || info.gotSize) )
3032 data = new wxPyUserData(userData);
3033 wxPyEndBlockThreads(blocked);
3034
3035 // Now call the real Prepend method if a valid item type was found
3036 if ( info.window )
3037 return self->Prepend(info.window, proportion, flag, border, data);
3038 else if ( info.sizer )
3039 return self->Prepend(info.sizer, proportion, flag, border, data);
3040 else if (info.gotSize)
3041 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3042 proportion, flag, border, data);
3043 else
3044 return NULL;
3045 }
3046 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3047 bool blocked = wxPyBeginBlockThreads();
3048 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3049 wxPyEndBlockThreads(blocked);
3050 if ( info.window )
3051 return self->Remove(info.window);
3052 else if ( info.sizer )
3053 return self->Remove(info.sizer);
3054 else if ( info.gotPos )
3055 return self->Remove(info.pos);
3056 else
3057 return false;
3058 }
3059 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3060 bool blocked = wxPyBeginBlockThreads();
3061 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3062 wxPyEndBlockThreads(blocked);
3063 if ( info.window )
3064 return self->Detach(info.window);
3065 else if ( info.sizer )
3066 return self->Detach(info.sizer);
3067 else if ( info.gotPos )
3068 return self->Detach(info.pos);
3069 else
3070 return false;
3071 }
3072 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3073 bool blocked = wxPyBeginBlockThreads();
3074 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3075 wxPyEndBlockThreads(blocked);
3076 if ( info.window )
3077 return self->GetItem(info.window);
3078 else if ( info.sizer )
3079 return self->GetItem(info.sizer);
3080 else if ( info.gotPos )
3081 return self->GetItem(info.pos);
3082 else
3083 return NULL;
3084 }
3085 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3086 bool blocked = wxPyBeginBlockThreads();
3087 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3088 wxPyEndBlockThreads(blocked);
3089 if ( info.window )
3090 self->SetItemMinSize(info.window, size);
3091 else if ( info.sizer )
3092 self->SetItemMinSize(info.sizer, size);
3093 else if ( info.gotPos )
3094 self->SetItemMinSize(info.pos, size);
3095 }
3096 static PyObject *wxSizer_GetChildren(wxSizer *self){
3097 wxSizerItemList& list = self->GetChildren();
3098 return wxPy_ConvertList(&list);
3099 }
3100 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3101 bool blocked = wxPyBeginBlockThreads();
3102 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3103 wxPyEndBlockThreads(blocked);
3104 if ( info.window )
3105 return self->Show(info.window, show, recursive);
3106 else if ( info.sizer )
3107 return self->Show(info.sizer, show, recursive);
3108 else if ( info.gotPos )
3109 return self->Show(info.pos, show);
3110 else
3111 return false;
3112 }
3113 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3114 bool blocked = wxPyBeginBlockThreads();
3115 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3116 wxPyEndBlockThreads(blocked);
3117 if ( info.window )
3118 return self->IsShown(info.window);
3119 else if ( info.sizer )
3120 return self->IsShown(info.sizer);
3121 else if ( info.gotPos )
3122 return self->IsShown(info.pos);
3123 else
3124 return false;
3125 }
3126
3127 // See pyclasses.h
3128 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3129 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3130 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3131
3132
3133
3134
3135 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3136 {
3137 if (source == Py_None) {
3138 **obj = wxGBPosition(-1,-1);
3139 return true;
3140 }
3141 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3142 }
3143
3144 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3145 {
3146 if (source == Py_None) {
3147 **obj = wxGBSpan(-1,-1);
3148 return true;
3149 }
3150 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3151 }
3152
3153
3154 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3155 self->SetRow(row);
3156 self->SetCol(col);
3157 }
3158 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3159 bool blocked = wxPyBeginBlockThreads();
3160 PyObject* tup = PyTuple_New(2);
3161 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3162 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3163 wxPyEndBlockThreads(blocked);
3164 return tup;
3165 }
3166 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3167 self->SetRowspan(rowspan);
3168 self->SetColspan(colspan);
3169 }
3170 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3171 bool blocked = wxPyBeginBlockThreads();
3172 PyObject* tup = PyTuple_New(2);
3173 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3174 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3175 wxPyEndBlockThreads(blocked);
3176 return tup;
3177 }
3178 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3179 wxPyUserData* data = NULL;
3180 if ( userData ) {
3181 bool blocked = wxPyBeginBlockThreads();
3182 data = new wxPyUserData(userData);
3183 wxPyEndBlockThreads(blocked);
3184 }
3185 return new wxGBSizerItem(window, pos, span, flag, border, data);
3186 }
3187 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3188 wxPyUserData* data = NULL;
3189 if ( userData ) {
3190 bool blocked = wxPyBeginBlockThreads();
3191 data = new wxPyUserData(userData);
3192 wxPyEndBlockThreads(blocked);
3193 }
3194 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3195 }
3196 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3197 wxPyUserData* data = NULL;
3198 if ( userData ) {
3199 bool blocked = wxPyBeginBlockThreads();
3200 data = new wxPyUserData(userData);
3201 wxPyEndBlockThreads(blocked);
3202 }
3203 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3204 }
3205 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3206 int row, col;
3207 self->GetEndPos(row, col);
3208 return wxGBPosition(row, col);
3209 }
3210 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3211
3212 wxPyUserData* data = NULL;
3213 bool blocked = wxPyBeginBlockThreads();
3214 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3215 if ( userData && (info.window || info.sizer || info.gotSize) )
3216 data = new wxPyUserData(userData);
3217 wxPyEndBlockThreads(blocked);
3218
3219 // Now call the real Add method if a valid item type was found
3220 if ( info.window )
3221 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3222 else if ( info.sizer )
3223 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3224 else if (info.gotSize)
3225 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3226 pos, span, flag, border, data);
3227 return NULL;
3228 }
3229
3230
3231 #ifdef __cplusplus
3232 extern "C" {
3233 #endif
3234 static int _wrap_EmptyString_set(PyObject *) {
3235 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3236 return 1;
3237 }
3238
3239
3240 static PyObject *_wrap_EmptyString_get(void) {
3241 PyObject *pyobj;
3242
3243 {
3244 #if wxUSE_UNICODE
3245 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3246 #else
3247 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3248 #endif
3249 }
3250 return pyobj;
3251 }
3252
3253
3254 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3255 PyObject *resultobj;
3256 wxObject *arg1 = (wxObject *) 0 ;
3257 wxString result;
3258 PyObject * obj0 = 0 ;
3259 char *kwnames[] = {
3260 (char *) "self", NULL
3261 };
3262
3263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3265 if (SWIG_arg_fail(1)) SWIG_fail;
3266 {
3267 PyThreadState* __tstate = wxPyBeginAllowThreads();
3268 result = wxObject_GetClassName(arg1);
3269
3270 wxPyEndAllowThreads(__tstate);
3271 if (PyErr_Occurred()) SWIG_fail;
3272 }
3273 {
3274 #if wxUSE_UNICODE
3275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3276 #else
3277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3278 #endif
3279 }
3280 return resultobj;
3281 fail:
3282 return NULL;
3283 }
3284
3285
3286 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3287 PyObject *resultobj;
3288 wxObject *arg1 = (wxObject *) 0 ;
3289 PyObject * obj0 = 0 ;
3290 char *kwnames[] = {
3291 (char *) "self", NULL
3292 };
3293
3294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3296 if (SWIG_arg_fail(1)) SWIG_fail;
3297 {
3298 PyThreadState* __tstate = wxPyBeginAllowThreads();
3299 wxObject_Destroy(arg1);
3300
3301 wxPyEndAllowThreads(__tstate);
3302 if (PyErr_Occurred()) SWIG_fail;
3303 }
3304 Py_INCREF(Py_None); resultobj = Py_None;
3305 return resultobj;
3306 fail:
3307 return NULL;
3308 }
3309
3310
3311 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3312 PyObject *obj;
3313 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3314 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3315 Py_INCREF(obj);
3316 return Py_BuildValue((char *)"");
3317 }
3318 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3319 PyObject *resultobj;
3320 wxSize *arg1 = (wxSize *) 0 ;
3321 int arg2 ;
3322 PyObject * obj0 = 0 ;
3323 PyObject * obj1 = 0 ;
3324 char *kwnames[] = {
3325 (char *) "self",(char *) "x", NULL
3326 };
3327
3328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3330 if (SWIG_arg_fail(1)) SWIG_fail;
3331 {
3332 arg2 = (int)(SWIG_As_int(obj1));
3333 if (SWIG_arg_fail(2)) SWIG_fail;
3334 }
3335 if (arg1) (arg1)->x = arg2;
3336
3337 Py_INCREF(Py_None); resultobj = Py_None;
3338 return resultobj;
3339 fail:
3340 return NULL;
3341 }
3342
3343
3344 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3345 PyObject *resultobj;
3346 wxSize *arg1 = (wxSize *) 0 ;
3347 int result;
3348 PyObject * obj0 = 0 ;
3349 char *kwnames[] = {
3350 (char *) "self", NULL
3351 };
3352
3353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3355 if (SWIG_arg_fail(1)) SWIG_fail;
3356 result = (int) ((arg1)->x);
3357
3358 {
3359 resultobj = SWIG_From_int((int)(result));
3360 }
3361 return resultobj;
3362 fail:
3363 return NULL;
3364 }
3365
3366
3367 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3368 PyObject *resultobj;
3369 wxSize *arg1 = (wxSize *) 0 ;
3370 int arg2 ;
3371 PyObject * obj0 = 0 ;
3372 PyObject * obj1 = 0 ;
3373 char *kwnames[] = {
3374 (char *) "self",(char *) "y", NULL
3375 };
3376
3377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3379 if (SWIG_arg_fail(1)) SWIG_fail;
3380 {
3381 arg2 = (int)(SWIG_As_int(obj1));
3382 if (SWIG_arg_fail(2)) SWIG_fail;
3383 }
3384 if (arg1) (arg1)->y = arg2;
3385
3386 Py_INCREF(Py_None); resultobj = Py_None;
3387 return resultobj;
3388 fail:
3389 return NULL;
3390 }
3391
3392
3393 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3394 PyObject *resultobj;
3395 wxSize *arg1 = (wxSize *) 0 ;
3396 int result;
3397 PyObject * obj0 = 0 ;
3398 char *kwnames[] = {
3399 (char *) "self", NULL
3400 };
3401
3402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3404 if (SWIG_arg_fail(1)) SWIG_fail;
3405 result = (int) ((arg1)->y);
3406
3407 {
3408 resultobj = SWIG_From_int((int)(result));
3409 }
3410 return resultobj;
3411 fail:
3412 return NULL;
3413 }
3414
3415
3416 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3417 PyObject *resultobj;
3418 int arg1 = (int) 0 ;
3419 int arg2 = (int) 0 ;
3420 wxSize *result;
3421 PyObject * obj0 = 0 ;
3422 PyObject * obj1 = 0 ;
3423 char *kwnames[] = {
3424 (char *) "w",(char *) "h", NULL
3425 };
3426
3427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3428 if (obj0) {
3429 {
3430 arg1 = (int)(SWIG_As_int(obj0));
3431 if (SWIG_arg_fail(1)) SWIG_fail;
3432 }
3433 }
3434 if (obj1) {
3435 {
3436 arg2 = (int)(SWIG_As_int(obj1));
3437 if (SWIG_arg_fail(2)) SWIG_fail;
3438 }
3439 }
3440 {
3441 PyThreadState* __tstate = wxPyBeginAllowThreads();
3442 result = (wxSize *)new wxSize(arg1,arg2);
3443
3444 wxPyEndAllowThreads(__tstate);
3445 if (PyErr_Occurred()) SWIG_fail;
3446 }
3447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3448 return resultobj;
3449 fail:
3450 return NULL;
3451 }
3452
3453
3454 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3455 PyObject *resultobj;
3456 wxSize *arg1 = (wxSize *) 0 ;
3457 PyObject * obj0 = 0 ;
3458 char *kwnames[] = {
3459 (char *) "self", NULL
3460 };
3461
3462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3464 if (SWIG_arg_fail(1)) SWIG_fail;
3465 {
3466 PyThreadState* __tstate = wxPyBeginAllowThreads();
3467 delete arg1;
3468
3469 wxPyEndAllowThreads(__tstate);
3470 if (PyErr_Occurred()) SWIG_fail;
3471 }
3472 Py_INCREF(Py_None); resultobj = Py_None;
3473 return resultobj;
3474 fail:
3475 return NULL;
3476 }
3477
3478
3479 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3480 PyObject *resultobj;
3481 wxSize *arg1 = (wxSize *) 0 ;
3482 wxSize *arg2 = 0 ;
3483 bool result;
3484 wxSize temp2 ;
3485 PyObject * obj0 = 0 ;
3486 PyObject * obj1 = 0 ;
3487 char *kwnames[] = {
3488 (char *) "self",(char *) "sz", NULL
3489 };
3490
3491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3493 if (SWIG_arg_fail(1)) SWIG_fail;
3494 {
3495 arg2 = &temp2;
3496 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3497 }
3498 {
3499 PyThreadState* __tstate = wxPyBeginAllowThreads();
3500 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3501
3502 wxPyEndAllowThreads(__tstate);
3503 if (PyErr_Occurred()) SWIG_fail;
3504 }
3505 {
3506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3507 }
3508 return resultobj;
3509 fail:
3510 return NULL;
3511 }
3512
3513
3514 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3515 PyObject *resultobj;
3516 wxSize *arg1 = (wxSize *) 0 ;
3517 wxSize *arg2 = 0 ;
3518 bool result;
3519 wxSize temp2 ;
3520 PyObject * obj0 = 0 ;
3521 PyObject * obj1 = 0 ;
3522 char *kwnames[] = {
3523 (char *) "self",(char *) "sz", NULL
3524 };
3525
3526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3528 if (SWIG_arg_fail(1)) SWIG_fail;
3529 {
3530 arg2 = &temp2;
3531 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3532 }
3533 {
3534 PyThreadState* __tstate = wxPyBeginAllowThreads();
3535 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3536
3537 wxPyEndAllowThreads(__tstate);
3538 if (PyErr_Occurred()) SWIG_fail;
3539 }
3540 {
3541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3542 }
3543 return resultobj;
3544 fail:
3545 return NULL;
3546 }
3547
3548
3549 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3550 PyObject *resultobj;
3551 wxSize *arg1 = (wxSize *) 0 ;
3552 wxSize *arg2 = 0 ;
3553 wxSize result;
3554 wxSize temp2 ;
3555 PyObject * obj0 = 0 ;
3556 PyObject * obj1 = 0 ;
3557 char *kwnames[] = {
3558 (char *) "self",(char *) "sz", NULL
3559 };
3560
3561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3563 if (SWIG_arg_fail(1)) SWIG_fail;
3564 {
3565 arg2 = &temp2;
3566 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3567 }
3568 {
3569 PyThreadState* __tstate = wxPyBeginAllowThreads();
3570 result = (arg1)->operator +((wxSize const &)*arg2);
3571
3572 wxPyEndAllowThreads(__tstate);
3573 if (PyErr_Occurred()) SWIG_fail;
3574 }
3575 {
3576 wxSize * resultptr;
3577 resultptr = new wxSize((wxSize &)(result));
3578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3579 }
3580 return resultobj;
3581 fail:
3582 return NULL;
3583 }
3584
3585
3586 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3587 PyObject *resultobj;
3588 wxSize *arg1 = (wxSize *) 0 ;
3589 wxSize *arg2 = 0 ;
3590 wxSize result;
3591 wxSize temp2 ;
3592 PyObject * obj0 = 0 ;
3593 PyObject * obj1 = 0 ;
3594 char *kwnames[] = {
3595 (char *) "self",(char *) "sz", NULL
3596 };
3597
3598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3600 if (SWIG_arg_fail(1)) SWIG_fail;
3601 {
3602 arg2 = &temp2;
3603 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3604 }
3605 {
3606 PyThreadState* __tstate = wxPyBeginAllowThreads();
3607 result = (arg1)->operator -((wxSize const &)*arg2);
3608
3609 wxPyEndAllowThreads(__tstate);
3610 if (PyErr_Occurred()) SWIG_fail;
3611 }
3612 {
3613 wxSize * resultptr;
3614 resultptr = new wxSize((wxSize &)(result));
3615 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3616 }
3617 return resultobj;
3618 fail:
3619 return NULL;
3620 }
3621
3622
3623 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3624 PyObject *resultobj;
3625 wxSize *arg1 = (wxSize *) 0 ;
3626 wxSize *arg2 = 0 ;
3627 wxSize temp2 ;
3628 PyObject * obj0 = 0 ;
3629 PyObject * obj1 = 0 ;
3630 char *kwnames[] = {
3631 (char *) "self",(char *) "sz", NULL
3632 };
3633
3634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3636 if (SWIG_arg_fail(1)) SWIG_fail;
3637 {
3638 arg2 = &temp2;
3639 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3640 }
3641 {
3642 PyThreadState* __tstate = wxPyBeginAllowThreads();
3643 (arg1)->IncTo((wxSize const &)*arg2);
3644
3645 wxPyEndAllowThreads(__tstate);
3646 if (PyErr_Occurred()) SWIG_fail;
3647 }
3648 Py_INCREF(Py_None); resultobj = Py_None;
3649 return resultobj;
3650 fail:
3651 return NULL;
3652 }
3653
3654
3655 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3656 PyObject *resultobj;
3657 wxSize *arg1 = (wxSize *) 0 ;
3658 wxSize *arg2 = 0 ;
3659 wxSize temp2 ;
3660 PyObject * obj0 = 0 ;
3661 PyObject * obj1 = 0 ;
3662 char *kwnames[] = {
3663 (char *) "self",(char *) "sz", NULL
3664 };
3665
3666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3668 if (SWIG_arg_fail(1)) SWIG_fail;
3669 {
3670 arg2 = &temp2;
3671 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3672 }
3673 {
3674 PyThreadState* __tstate = wxPyBeginAllowThreads();
3675 (arg1)->DecTo((wxSize const &)*arg2);
3676
3677 wxPyEndAllowThreads(__tstate);
3678 if (PyErr_Occurred()) SWIG_fail;
3679 }
3680 Py_INCREF(Py_None); resultobj = Py_None;
3681 return resultobj;
3682 fail:
3683 return NULL;
3684 }
3685
3686
3687 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3688 PyObject *resultobj;
3689 wxSize *arg1 = (wxSize *) 0 ;
3690 int arg2 ;
3691 int arg3 ;
3692 PyObject * obj0 = 0 ;
3693 PyObject * obj1 = 0 ;
3694 PyObject * obj2 = 0 ;
3695 char *kwnames[] = {
3696 (char *) "self",(char *) "w",(char *) "h", NULL
3697 };
3698
3699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3701 if (SWIG_arg_fail(1)) SWIG_fail;
3702 {
3703 arg2 = (int)(SWIG_As_int(obj1));
3704 if (SWIG_arg_fail(2)) SWIG_fail;
3705 }
3706 {
3707 arg3 = (int)(SWIG_As_int(obj2));
3708 if (SWIG_arg_fail(3)) SWIG_fail;
3709 }
3710 {
3711 PyThreadState* __tstate = wxPyBeginAllowThreads();
3712 (arg1)->Set(arg2,arg3);
3713
3714 wxPyEndAllowThreads(__tstate);
3715 if (PyErr_Occurred()) SWIG_fail;
3716 }
3717 Py_INCREF(Py_None); resultobj = Py_None;
3718 return resultobj;
3719 fail:
3720 return NULL;
3721 }
3722
3723
3724 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3725 PyObject *resultobj;
3726 wxSize *arg1 = (wxSize *) 0 ;
3727 int arg2 ;
3728 PyObject * obj0 = 0 ;
3729 PyObject * obj1 = 0 ;
3730 char *kwnames[] = {
3731 (char *) "self",(char *) "w", NULL
3732 };
3733
3734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3736 if (SWIG_arg_fail(1)) SWIG_fail;
3737 {
3738 arg2 = (int)(SWIG_As_int(obj1));
3739 if (SWIG_arg_fail(2)) SWIG_fail;
3740 }
3741 {
3742 PyThreadState* __tstate = wxPyBeginAllowThreads();
3743 (arg1)->SetWidth(arg2);
3744
3745 wxPyEndAllowThreads(__tstate);
3746 if (PyErr_Occurred()) SWIG_fail;
3747 }
3748 Py_INCREF(Py_None); resultobj = Py_None;
3749 return resultobj;
3750 fail:
3751 return NULL;
3752 }
3753
3754
3755 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3756 PyObject *resultobj;
3757 wxSize *arg1 = (wxSize *) 0 ;
3758 int arg2 ;
3759 PyObject * obj0 = 0 ;
3760 PyObject * obj1 = 0 ;
3761 char *kwnames[] = {
3762 (char *) "self",(char *) "h", NULL
3763 };
3764
3765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3767 if (SWIG_arg_fail(1)) SWIG_fail;
3768 {
3769 arg2 = (int)(SWIG_As_int(obj1));
3770 if (SWIG_arg_fail(2)) SWIG_fail;
3771 }
3772 {
3773 PyThreadState* __tstate = wxPyBeginAllowThreads();
3774 (arg1)->SetHeight(arg2);
3775
3776 wxPyEndAllowThreads(__tstate);
3777 if (PyErr_Occurred()) SWIG_fail;
3778 }
3779 Py_INCREF(Py_None); resultobj = Py_None;
3780 return resultobj;
3781 fail:
3782 return NULL;
3783 }
3784
3785
3786 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3787 PyObject *resultobj;
3788 wxSize *arg1 = (wxSize *) 0 ;
3789 int result;
3790 PyObject * obj0 = 0 ;
3791 char *kwnames[] = {
3792 (char *) "self", NULL
3793 };
3794
3795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3797 if (SWIG_arg_fail(1)) SWIG_fail;
3798 {
3799 PyThreadState* __tstate = wxPyBeginAllowThreads();
3800 result = (int)((wxSize const *)arg1)->GetWidth();
3801
3802 wxPyEndAllowThreads(__tstate);
3803 if (PyErr_Occurred()) SWIG_fail;
3804 }
3805 {
3806 resultobj = SWIG_From_int((int)(result));
3807 }
3808 return resultobj;
3809 fail:
3810 return NULL;
3811 }
3812
3813
3814 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3815 PyObject *resultobj;
3816 wxSize *arg1 = (wxSize *) 0 ;
3817 int result;
3818 PyObject * obj0 = 0 ;
3819 char *kwnames[] = {
3820 (char *) "self", NULL
3821 };
3822
3823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3825 if (SWIG_arg_fail(1)) SWIG_fail;
3826 {
3827 PyThreadState* __tstate = wxPyBeginAllowThreads();
3828 result = (int)((wxSize const *)arg1)->GetHeight();
3829
3830 wxPyEndAllowThreads(__tstate);
3831 if (PyErr_Occurred()) SWIG_fail;
3832 }
3833 {
3834 resultobj = SWIG_From_int((int)(result));
3835 }
3836 return resultobj;
3837 fail:
3838 return NULL;
3839 }
3840
3841
3842 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3843 PyObject *resultobj;
3844 wxSize *arg1 = (wxSize *) 0 ;
3845 bool result;
3846 PyObject * obj0 = 0 ;
3847 char *kwnames[] = {
3848 (char *) "self", NULL
3849 };
3850
3851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3853 if (SWIG_arg_fail(1)) SWIG_fail;
3854 {
3855 PyThreadState* __tstate = wxPyBeginAllowThreads();
3856 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3857
3858 wxPyEndAllowThreads(__tstate);
3859 if (PyErr_Occurred()) SWIG_fail;
3860 }
3861 {
3862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3863 }
3864 return resultobj;
3865 fail:
3866 return NULL;
3867 }
3868
3869
3870 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3871 PyObject *resultobj;
3872 wxSize *arg1 = (wxSize *) 0 ;
3873 wxSize *arg2 = 0 ;
3874 wxSize temp2 ;
3875 PyObject * obj0 = 0 ;
3876 PyObject * obj1 = 0 ;
3877 char *kwnames[] = {
3878 (char *) "self",(char *) "size", NULL
3879 };
3880
3881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3883 if (SWIG_arg_fail(1)) SWIG_fail;
3884 {
3885 arg2 = &temp2;
3886 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3887 }
3888 {
3889 PyThreadState* __tstate = wxPyBeginAllowThreads();
3890 (arg1)->SetDefaults((wxSize const &)*arg2);
3891
3892 wxPyEndAllowThreads(__tstate);
3893 if (PyErr_Occurred()) SWIG_fail;
3894 }
3895 Py_INCREF(Py_None); resultobj = Py_None;
3896 return resultobj;
3897 fail:
3898 return NULL;
3899 }
3900
3901
3902 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3903 PyObject *resultobj;
3904 wxSize *arg1 = (wxSize *) 0 ;
3905 PyObject *result;
3906 PyObject * obj0 = 0 ;
3907 char *kwnames[] = {
3908 (char *) "self", NULL
3909 };
3910
3911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3913 if (SWIG_arg_fail(1)) SWIG_fail;
3914 {
3915 PyThreadState* __tstate = wxPyBeginAllowThreads();
3916 result = (PyObject *)wxSize_Get(arg1);
3917
3918 wxPyEndAllowThreads(__tstate);
3919 if (PyErr_Occurred()) SWIG_fail;
3920 }
3921 resultobj = result;
3922 return resultobj;
3923 fail:
3924 return NULL;
3925 }
3926
3927
3928 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3929 PyObject *obj;
3930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3931 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3932 Py_INCREF(obj);
3933 return Py_BuildValue((char *)"");
3934 }
3935 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3936 PyObject *resultobj;
3937 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3938 double arg2 ;
3939 PyObject * obj0 = 0 ;
3940 PyObject * obj1 = 0 ;
3941 char *kwnames[] = {
3942 (char *) "self",(char *) "x", NULL
3943 };
3944
3945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3947 if (SWIG_arg_fail(1)) SWIG_fail;
3948 {
3949 arg2 = (double)(SWIG_As_double(obj1));
3950 if (SWIG_arg_fail(2)) SWIG_fail;
3951 }
3952 if (arg1) (arg1)->x = arg2;
3953
3954 Py_INCREF(Py_None); resultobj = Py_None;
3955 return resultobj;
3956 fail:
3957 return NULL;
3958 }
3959
3960
3961 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3962 PyObject *resultobj;
3963 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3964 double result;
3965 PyObject * obj0 = 0 ;
3966 char *kwnames[] = {
3967 (char *) "self", NULL
3968 };
3969
3970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3972 if (SWIG_arg_fail(1)) SWIG_fail;
3973 result = (double) ((arg1)->x);
3974
3975 {
3976 resultobj = SWIG_From_double((double)(result));
3977 }
3978 return resultobj;
3979 fail:
3980 return NULL;
3981 }
3982
3983
3984 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3985 PyObject *resultobj;
3986 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3987 double arg2 ;
3988 PyObject * obj0 = 0 ;
3989 PyObject * obj1 = 0 ;
3990 char *kwnames[] = {
3991 (char *) "self",(char *) "y", NULL
3992 };
3993
3994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3996 if (SWIG_arg_fail(1)) SWIG_fail;
3997 {
3998 arg2 = (double)(SWIG_As_double(obj1));
3999 if (SWIG_arg_fail(2)) SWIG_fail;
4000 }
4001 if (arg1) (arg1)->y = arg2;
4002
4003 Py_INCREF(Py_None); resultobj = Py_None;
4004 return resultobj;
4005 fail:
4006 return NULL;
4007 }
4008
4009
4010 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4011 PyObject *resultobj;
4012 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4013 double result;
4014 PyObject * obj0 = 0 ;
4015 char *kwnames[] = {
4016 (char *) "self", NULL
4017 };
4018
4019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4021 if (SWIG_arg_fail(1)) SWIG_fail;
4022 result = (double) ((arg1)->y);
4023
4024 {
4025 resultobj = SWIG_From_double((double)(result));
4026 }
4027 return resultobj;
4028 fail:
4029 return NULL;
4030 }
4031
4032
4033 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4034 PyObject *resultobj;
4035 double arg1 = (double) 0.0 ;
4036 double arg2 = (double) 0.0 ;
4037 wxRealPoint *result;
4038 PyObject * obj0 = 0 ;
4039 PyObject * obj1 = 0 ;
4040 char *kwnames[] = {
4041 (char *) "x",(char *) "y", NULL
4042 };
4043
4044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4045 if (obj0) {
4046 {
4047 arg1 = (double)(SWIG_As_double(obj0));
4048 if (SWIG_arg_fail(1)) SWIG_fail;
4049 }
4050 }
4051 if (obj1) {
4052 {
4053 arg2 = (double)(SWIG_As_double(obj1));
4054 if (SWIG_arg_fail(2)) SWIG_fail;
4055 }
4056 }
4057 {
4058 PyThreadState* __tstate = wxPyBeginAllowThreads();
4059 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4060
4061 wxPyEndAllowThreads(__tstate);
4062 if (PyErr_Occurred()) SWIG_fail;
4063 }
4064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4065 return resultobj;
4066 fail:
4067 return NULL;
4068 }
4069
4070
4071 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4072 PyObject *resultobj;
4073 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4074 PyObject * obj0 = 0 ;
4075 char *kwnames[] = {
4076 (char *) "self", NULL
4077 };
4078
4079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4081 if (SWIG_arg_fail(1)) SWIG_fail;
4082 {
4083 PyThreadState* __tstate = wxPyBeginAllowThreads();
4084 delete arg1;
4085
4086 wxPyEndAllowThreads(__tstate);
4087 if (PyErr_Occurred()) SWIG_fail;
4088 }
4089 Py_INCREF(Py_None); resultobj = Py_None;
4090 return resultobj;
4091 fail:
4092 return NULL;
4093 }
4094
4095
4096 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4097 PyObject *resultobj;
4098 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4099 wxRealPoint *arg2 = 0 ;
4100 bool result;
4101 wxRealPoint temp2 ;
4102 PyObject * obj0 = 0 ;
4103 PyObject * obj1 = 0 ;
4104 char *kwnames[] = {
4105 (char *) "self",(char *) "pt", NULL
4106 };
4107
4108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4110 if (SWIG_arg_fail(1)) SWIG_fail;
4111 {
4112 arg2 = &temp2;
4113 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4114 }
4115 {
4116 PyThreadState* __tstate = wxPyBeginAllowThreads();
4117 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4118
4119 wxPyEndAllowThreads(__tstate);
4120 if (PyErr_Occurred()) SWIG_fail;
4121 }
4122 {
4123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4124 }
4125 return resultobj;
4126 fail:
4127 return NULL;
4128 }
4129
4130
4131 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4132 PyObject *resultobj;
4133 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4134 wxRealPoint *arg2 = 0 ;
4135 bool result;
4136 wxRealPoint temp2 ;
4137 PyObject * obj0 = 0 ;
4138 PyObject * obj1 = 0 ;
4139 char *kwnames[] = {
4140 (char *) "self",(char *) "pt", NULL
4141 };
4142
4143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4145 if (SWIG_arg_fail(1)) SWIG_fail;
4146 {
4147 arg2 = &temp2;
4148 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4149 }
4150 {
4151 PyThreadState* __tstate = wxPyBeginAllowThreads();
4152 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4153
4154 wxPyEndAllowThreads(__tstate);
4155 if (PyErr_Occurred()) SWIG_fail;
4156 }
4157 {
4158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4159 }
4160 return resultobj;
4161 fail:
4162 return NULL;
4163 }
4164
4165
4166 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4167 PyObject *resultobj;
4168 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4169 wxRealPoint *arg2 = 0 ;
4170 wxRealPoint result;
4171 wxRealPoint temp2 ;
4172 PyObject * obj0 = 0 ;
4173 PyObject * obj1 = 0 ;
4174 char *kwnames[] = {
4175 (char *) "self",(char *) "pt", NULL
4176 };
4177
4178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4180 if (SWIG_arg_fail(1)) SWIG_fail;
4181 {
4182 arg2 = &temp2;
4183 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4184 }
4185 {
4186 PyThreadState* __tstate = wxPyBeginAllowThreads();
4187 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4188
4189 wxPyEndAllowThreads(__tstate);
4190 if (PyErr_Occurred()) SWIG_fail;
4191 }
4192 {
4193 wxRealPoint * resultptr;
4194 resultptr = new wxRealPoint((wxRealPoint &)(result));
4195 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4196 }
4197 return resultobj;
4198 fail:
4199 return NULL;
4200 }
4201
4202
4203 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4204 PyObject *resultobj;
4205 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4206 wxRealPoint *arg2 = 0 ;
4207 wxRealPoint result;
4208 wxRealPoint temp2 ;
4209 PyObject * obj0 = 0 ;
4210 PyObject * obj1 = 0 ;
4211 char *kwnames[] = {
4212 (char *) "self",(char *) "pt", NULL
4213 };
4214
4215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4217 if (SWIG_arg_fail(1)) SWIG_fail;
4218 {
4219 arg2 = &temp2;
4220 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4221 }
4222 {
4223 PyThreadState* __tstate = wxPyBeginAllowThreads();
4224 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4225
4226 wxPyEndAllowThreads(__tstate);
4227 if (PyErr_Occurred()) SWIG_fail;
4228 }
4229 {
4230 wxRealPoint * resultptr;
4231 resultptr = new wxRealPoint((wxRealPoint &)(result));
4232 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4233 }
4234 return resultobj;
4235 fail:
4236 return NULL;
4237 }
4238
4239
4240 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4241 PyObject *resultobj;
4242 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4243 double arg2 ;
4244 double arg3 ;
4245 PyObject * obj0 = 0 ;
4246 PyObject * obj1 = 0 ;
4247 PyObject * obj2 = 0 ;
4248 char *kwnames[] = {
4249 (char *) "self",(char *) "x",(char *) "y", NULL
4250 };
4251
4252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4254 if (SWIG_arg_fail(1)) SWIG_fail;
4255 {
4256 arg2 = (double)(SWIG_As_double(obj1));
4257 if (SWIG_arg_fail(2)) SWIG_fail;
4258 }
4259 {
4260 arg3 = (double)(SWIG_As_double(obj2));
4261 if (SWIG_arg_fail(3)) SWIG_fail;
4262 }
4263 {
4264 PyThreadState* __tstate = wxPyBeginAllowThreads();
4265 wxRealPoint_Set(arg1,arg2,arg3);
4266
4267 wxPyEndAllowThreads(__tstate);
4268 if (PyErr_Occurred()) SWIG_fail;
4269 }
4270 Py_INCREF(Py_None); resultobj = Py_None;
4271 return resultobj;
4272 fail:
4273 return NULL;
4274 }
4275
4276
4277 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4278 PyObject *resultobj;
4279 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4280 PyObject *result;
4281 PyObject * obj0 = 0 ;
4282 char *kwnames[] = {
4283 (char *) "self", NULL
4284 };
4285
4286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4288 if (SWIG_arg_fail(1)) SWIG_fail;
4289 {
4290 PyThreadState* __tstate = wxPyBeginAllowThreads();
4291 result = (PyObject *)wxRealPoint_Get(arg1);
4292
4293 wxPyEndAllowThreads(__tstate);
4294 if (PyErr_Occurred()) SWIG_fail;
4295 }
4296 resultobj = result;
4297 return resultobj;
4298 fail:
4299 return NULL;
4300 }
4301
4302
4303 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4304 PyObject *obj;
4305 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4306 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4307 Py_INCREF(obj);
4308 return Py_BuildValue((char *)"");
4309 }
4310 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4311 PyObject *resultobj;
4312 wxPoint *arg1 = (wxPoint *) 0 ;
4313 int arg2 ;
4314 PyObject * obj0 = 0 ;
4315 PyObject * obj1 = 0 ;
4316 char *kwnames[] = {
4317 (char *) "self",(char *) "x", NULL
4318 };
4319
4320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4322 if (SWIG_arg_fail(1)) SWIG_fail;
4323 {
4324 arg2 = (int)(SWIG_As_int(obj1));
4325 if (SWIG_arg_fail(2)) SWIG_fail;
4326 }
4327 if (arg1) (arg1)->x = arg2;
4328
4329 Py_INCREF(Py_None); resultobj = Py_None;
4330 return resultobj;
4331 fail:
4332 return NULL;
4333 }
4334
4335
4336 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4337 PyObject *resultobj;
4338 wxPoint *arg1 = (wxPoint *) 0 ;
4339 int result;
4340 PyObject * obj0 = 0 ;
4341 char *kwnames[] = {
4342 (char *) "self", NULL
4343 };
4344
4345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4347 if (SWIG_arg_fail(1)) SWIG_fail;
4348 result = (int) ((arg1)->x);
4349
4350 {
4351 resultobj = SWIG_From_int((int)(result));
4352 }
4353 return resultobj;
4354 fail:
4355 return NULL;
4356 }
4357
4358
4359 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4360 PyObject *resultobj;
4361 wxPoint *arg1 = (wxPoint *) 0 ;
4362 int arg2 ;
4363 PyObject * obj0 = 0 ;
4364 PyObject * obj1 = 0 ;
4365 char *kwnames[] = {
4366 (char *) "self",(char *) "y", NULL
4367 };
4368
4369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4371 if (SWIG_arg_fail(1)) SWIG_fail;
4372 {
4373 arg2 = (int)(SWIG_As_int(obj1));
4374 if (SWIG_arg_fail(2)) SWIG_fail;
4375 }
4376 if (arg1) (arg1)->y = arg2;
4377
4378 Py_INCREF(Py_None); resultobj = Py_None;
4379 return resultobj;
4380 fail:
4381 return NULL;
4382 }
4383
4384
4385 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4386 PyObject *resultobj;
4387 wxPoint *arg1 = (wxPoint *) 0 ;
4388 int result;
4389 PyObject * obj0 = 0 ;
4390 char *kwnames[] = {
4391 (char *) "self", NULL
4392 };
4393
4394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4396 if (SWIG_arg_fail(1)) SWIG_fail;
4397 result = (int) ((arg1)->y);
4398
4399 {
4400 resultobj = SWIG_From_int((int)(result));
4401 }
4402 return resultobj;
4403 fail:
4404 return NULL;
4405 }
4406
4407
4408 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4409 PyObject *resultobj;
4410 int arg1 = (int) 0 ;
4411 int arg2 = (int) 0 ;
4412 wxPoint *result;
4413 PyObject * obj0 = 0 ;
4414 PyObject * obj1 = 0 ;
4415 char *kwnames[] = {
4416 (char *) "x",(char *) "y", NULL
4417 };
4418
4419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4420 if (obj0) {
4421 {
4422 arg1 = (int)(SWIG_As_int(obj0));
4423 if (SWIG_arg_fail(1)) SWIG_fail;
4424 }
4425 }
4426 if (obj1) {
4427 {
4428 arg2 = (int)(SWIG_As_int(obj1));
4429 if (SWIG_arg_fail(2)) SWIG_fail;
4430 }
4431 }
4432 {
4433 PyThreadState* __tstate = wxPyBeginAllowThreads();
4434 result = (wxPoint *)new wxPoint(arg1,arg2);
4435
4436 wxPyEndAllowThreads(__tstate);
4437 if (PyErr_Occurred()) SWIG_fail;
4438 }
4439 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4440 return resultobj;
4441 fail:
4442 return NULL;
4443 }
4444
4445
4446 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4447 PyObject *resultobj;
4448 wxPoint *arg1 = (wxPoint *) 0 ;
4449 PyObject * obj0 = 0 ;
4450 char *kwnames[] = {
4451 (char *) "self", NULL
4452 };
4453
4454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4456 if (SWIG_arg_fail(1)) SWIG_fail;
4457 {
4458 PyThreadState* __tstate = wxPyBeginAllowThreads();
4459 delete arg1;
4460
4461 wxPyEndAllowThreads(__tstate);
4462 if (PyErr_Occurred()) SWIG_fail;
4463 }
4464 Py_INCREF(Py_None); resultobj = Py_None;
4465 return resultobj;
4466 fail:
4467 return NULL;
4468 }
4469
4470
4471 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4472 PyObject *resultobj;
4473 wxPoint *arg1 = (wxPoint *) 0 ;
4474 wxPoint *arg2 = 0 ;
4475 bool result;
4476 wxPoint temp2 ;
4477 PyObject * obj0 = 0 ;
4478 PyObject * obj1 = 0 ;
4479 char *kwnames[] = {
4480 (char *) "self",(char *) "pt", NULL
4481 };
4482
4483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4485 if (SWIG_arg_fail(1)) SWIG_fail;
4486 {
4487 arg2 = &temp2;
4488 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4489 }
4490 {
4491 PyThreadState* __tstate = wxPyBeginAllowThreads();
4492 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4493
4494 wxPyEndAllowThreads(__tstate);
4495 if (PyErr_Occurred()) SWIG_fail;
4496 }
4497 {
4498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4499 }
4500 return resultobj;
4501 fail:
4502 return NULL;
4503 }
4504
4505
4506 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4507 PyObject *resultobj;
4508 wxPoint *arg1 = (wxPoint *) 0 ;
4509 wxPoint *arg2 = 0 ;
4510 bool result;
4511 wxPoint temp2 ;
4512 PyObject * obj0 = 0 ;
4513 PyObject * obj1 = 0 ;
4514 char *kwnames[] = {
4515 (char *) "self",(char *) "pt", NULL
4516 };
4517
4518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4520 if (SWIG_arg_fail(1)) SWIG_fail;
4521 {
4522 arg2 = &temp2;
4523 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4524 }
4525 {
4526 PyThreadState* __tstate = wxPyBeginAllowThreads();
4527 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4528
4529 wxPyEndAllowThreads(__tstate);
4530 if (PyErr_Occurred()) SWIG_fail;
4531 }
4532 {
4533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4534 }
4535 return resultobj;
4536 fail:
4537 return NULL;
4538 }
4539
4540
4541 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4542 PyObject *resultobj;
4543 wxPoint *arg1 = (wxPoint *) 0 ;
4544 wxPoint *arg2 = 0 ;
4545 wxPoint result;
4546 wxPoint temp2 ;
4547 PyObject * obj0 = 0 ;
4548 PyObject * obj1 = 0 ;
4549 char *kwnames[] = {
4550 (char *) "self",(char *) "pt", NULL
4551 };
4552
4553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4555 if (SWIG_arg_fail(1)) SWIG_fail;
4556 {
4557 arg2 = &temp2;
4558 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4559 }
4560 {
4561 PyThreadState* __tstate = wxPyBeginAllowThreads();
4562 result = (arg1)->operator +((wxPoint const &)*arg2);
4563
4564 wxPyEndAllowThreads(__tstate);
4565 if (PyErr_Occurred()) SWIG_fail;
4566 }
4567 {
4568 wxPoint * resultptr;
4569 resultptr = new wxPoint((wxPoint &)(result));
4570 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4571 }
4572 return resultobj;
4573 fail:
4574 return NULL;
4575 }
4576
4577
4578 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4579 PyObject *resultobj;
4580 wxPoint *arg1 = (wxPoint *) 0 ;
4581 wxPoint *arg2 = 0 ;
4582 wxPoint result;
4583 wxPoint temp2 ;
4584 PyObject * obj0 = 0 ;
4585 PyObject * obj1 = 0 ;
4586 char *kwnames[] = {
4587 (char *) "self",(char *) "pt", NULL
4588 };
4589
4590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4592 if (SWIG_arg_fail(1)) SWIG_fail;
4593 {
4594 arg2 = &temp2;
4595 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4596 }
4597 {
4598 PyThreadState* __tstate = wxPyBeginAllowThreads();
4599 result = (arg1)->operator -((wxPoint const &)*arg2);
4600
4601 wxPyEndAllowThreads(__tstate);
4602 if (PyErr_Occurred()) SWIG_fail;
4603 }
4604 {
4605 wxPoint * resultptr;
4606 resultptr = new wxPoint((wxPoint &)(result));
4607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4608 }
4609 return resultobj;
4610 fail:
4611 return NULL;
4612 }
4613
4614
4615 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4616 PyObject *resultobj;
4617 wxPoint *arg1 = (wxPoint *) 0 ;
4618 wxPoint *arg2 = 0 ;
4619 wxPoint *result;
4620 wxPoint temp2 ;
4621 PyObject * obj0 = 0 ;
4622 PyObject * obj1 = 0 ;
4623 char *kwnames[] = {
4624 (char *) "self",(char *) "pt", NULL
4625 };
4626
4627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4629 if (SWIG_arg_fail(1)) SWIG_fail;
4630 {
4631 arg2 = &temp2;
4632 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4633 }
4634 {
4635 PyThreadState* __tstate = wxPyBeginAllowThreads();
4636 {
4637 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4638 result = (wxPoint *) &_result_ref;
4639 }
4640
4641 wxPyEndAllowThreads(__tstate);
4642 if (PyErr_Occurred()) SWIG_fail;
4643 }
4644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4645 return resultobj;
4646 fail:
4647 return NULL;
4648 }
4649
4650
4651 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4652 PyObject *resultobj;
4653 wxPoint *arg1 = (wxPoint *) 0 ;
4654 wxPoint *arg2 = 0 ;
4655 wxPoint *result;
4656 wxPoint temp2 ;
4657 PyObject * obj0 = 0 ;
4658 PyObject * obj1 = 0 ;
4659 char *kwnames[] = {
4660 (char *) "self",(char *) "pt", NULL
4661 };
4662
4663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4665 if (SWIG_arg_fail(1)) SWIG_fail;
4666 {
4667 arg2 = &temp2;
4668 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4669 }
4670 {
4671 PyThreadState* __tstate = wxPyBeginAllowThreads();
4672 {
4673 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4674 result = (wxPoint *) &_result_ref;
4675 }
4676
4677 wxPyEndAllowThreads(__tstate);
4678 if (PyErr_Occurred()) SWIG_fail;
4679 }
4680 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4681 return resultobj;
4682 fail:
4683 return NULL;
4684 }
4685
4686
4687 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4688 PyObject *resultobj;
4689 wxPoint *arg1 = (wxPoint *) 0 ;
4690 long arg2 ;
4691 long arg3 ;
4692 PyObject * obj0 = 0 ;
4693 PyObject * obj1 = 0 ;
4694 PyObject * obj2 = 0 ;
4695 char *kwnames[] = {
4696 (char *) "self",(char *) "x",(char *) "y", NULL
4697 };
4698
4699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4701 if (SWIG_arg_fail(1)) SWIG_fail;
4702 {
4703 arg2 = (long)(SWIG_As_long(obj1));
4704 if (SWIG_arg_fail(2)) SWIG_fail;
4705 }
4706 {
4707 arg3 = (long)(SWIG_As_long(obj2));
4708 if (SWIG_arg_fail(3)) SWIG_fail;
4709 }
4710 {
4711 PyThreadState* __tstate = wxPyBeginAllowThreads();
4712 wxPoint_Set(arg1,arg2,arg3);
4713
4714 wxPyEndAllowThreads(__tstate);
4715 if (PyErr_Occurred()) SWIG_fail;
4716 }
4717 Py_INCREF(Py_None); resultobj = Py_None;
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj;
4726 wxPoint *arg1 = (wxPoint *) 0 ;
4727 PyObject *result;
4728 PyObject * obj0 = 0 ;
4729 char *kwnames[] = {
4730 (char *) "self", NULL
4731 };
4732
4733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4735 if (SWIG_arg_fail(1)) SWIG_fail;
4736 {
4737 PyThreadState* __tstate = wxPyBeginAllowThreads();
4738 result = (PyObject *)wxPoint_Get(arg1);
4739
4740 wxPyEndAllowThreads(__tstate);
4741 if (PyErr_Occurred()) SWIG_fail;
4742 }
4743 resultobj = result;
4744 return resultobj;
4745 fail:
4746 return NULL;
4747 }
4748
4749
4750 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4751 PyObject *obj;
4752 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4753 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4754 Py_INCREF(obj);
4755 return Py_BuildValue((char *)"");
4756 }
4757 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4758 PyObject *resultobj;
4759 int arg1 = (int) 0 ;
4760 int arg2 = (int) 0 ;
4761 int arg3 = (int) 0 ;
4762 int arg4 = (int) 0 ;
4763 wxRect *result;
4764 PyObject * obj0 = 0 ;
4765 PyObject * obj1 = 0 ;
4766 PyObject * obj2 = 0 ;
4767 PyObject * obj3 = 0 ;
4768 char *kwnames[] = {
4769 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4770 };
4771
4772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4773 if (obj0) {
4774 {
4775 arg1 = (int)(SWIG_As_int(obj0));
4776 if (SWIG_arg_fail(1)) SWIG_fail;
4777 }
4778 }
4779 if (obj1) {
4780 {
4781 arg2 = (int)(SWIG_As_int(obj1));
4782 if (SWIG_arg_fail(2)) SWIG_fail;
4783 }
4784 }
4785 if (obj2) {
4786 {
4787 arg3 = (int)(SWIG_As_int(obj2));
4788 if (SWIG_arg_fail(3)) SWIG_fail;
4789 }
4790 }
4791 if (obj3) {
4792 {
4793 arg4 = (int)(SWIG_As_int(obj3));
4794 if (SWIG_arg_fail(4)) SWIG_fail;
4795 }
4796 }
4797 {
4798 PyThreadState* __tstate = wxPyBeginAllowThreads();
4799 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4800
4801 wxPyEndAllowThreads(__tstate);
4802 if (PyErr_Occurred()) SWIG_fail;
4803 }
4804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4805 return resultobj;
4806 fail:
4807 return NULL;
4808 }
4809
4810
4811 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4812 PyObject *resultobj;
4813 wxPoint *arg1 = 0 ;
4814 wxPoint *arg2 = 0 ;
4815 wxRect *result;
4816 wxPoint temp1 ;
4817 wxPoint temp2 ;
4818 PyObject * obj0 = 0 ;
4819 PyObject * obj1 = 0 ;
4820 char *kwnames[] = {
4821 (char *) "topLeft",(char *) "bottomRight", NULL
4822 };
4823
4824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4825 {
4826 arg1 = &temp1;
4827 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4828 }
4829 {
4830 arg2 = &temp2;
4831 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4832 }
4833 {
4834 PyThreadState* __tstate = wxPyBeginAllowThreads();
4835 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4836
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4841 return resultobj;
4842 fail:
4843 return NULL;
4844 }
4845
4846
4847 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4848 PyObject *resultobj;
4849 wxPoint *arg1 = 0 ;
4850 wxSize *arg2 = 0 ;
4851 wxRect *result;
4852 wxPoint temp1 ;
4853 wxSize temp2 ;
4854 PyObject * obj0 = 0 ;
4855 PyObject * obj1 = 0 ;
4856 char *kwnames[] = {
4857 (char *) "pos",(char *) "size", NULL
4858 };
4859
4860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4861 {
4862 arg1 = &temp1;
4863 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4864 }
4865 {
4866 arg2 = &temp2;
4867 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4868 }
4869 {
4870 PyThreadState* __tstate = wxPyBeginAllowThreads();
4871 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4872
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4877 return resultobj;
4878 fail:
4879 return NULL;
4880 }
4881
4882
4883 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4884 PyObject *resultobj;
4885 wxSize *arg1 = 0 ;
4886 wxRect *result;
4887 wxSize temp1 ;
4888 PyObject * obj0 = 0 ;
4889 char *kwnames[] = {
4890 (char *) "size", NULL
4891 };
4892
4893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4894 {
4895 arg1 = &temp1;
4896 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4897 }
4898 {
4899 PyThreadState* __tstate = wxPyBeginAllowThreads();
4900 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4901
4902 wxPyEndAllowThreads(__tstate);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4913 PyObject *resultobj;
4914 wxRect *arg1 = (wxRect *) 0 ;
4915 PyObject * obj0 = 0 ;
4916 char *kwnames[] = {
4917 (char *) "self", NULL
4918 };
4919
4920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4922 if (SWIG_arg_fail(1)) SWIG_fail;
4923 {
4924 PyThreadState* __tstate = wxPyBeginAllowThreads();
4925 delete arg1;
4926
4927 wxPyEndAllowThreads(__tstate);
4928 if (PyErr_Occurred()) SWIG_fail;
4929 }
4930 Py_INCREF(Py_None); resultobj = Py_None;
4931 return resultobj;
4932 fail:
4933 return NULL;
4934 }
4935
4936
4937 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4938 PyObject *resultobj;
4939 wxRect *arg1 = (wxRect *) 0 ;
4940 int result;
4941 PyObject * obj0 = 0 ;
4942 char *kwnames[] = {
4943 (char *) "self", NULL
4944 };
4945
4946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4948 if (SWIG_arg_fail(1)) SWIG_fail;
4949 {
4950 PyThreadState* __tstate = wxPyBeginAllowThreads();
4951 result = (int)((wxRect const *)arg1)->GetX();
4952
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 {
4957 resultobj = SWIG_From_int((int)(result));
4958 }
4959 return resultobj;
4960 fail:
4961 return NULL;
4962 }
4963
4964
4965 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4966 PyObject *resultobj;
4967 wxRect *arg1 = (wxRect *) 0 ;
4968 int arg2 ;
4969 PyObject * obj0 = 0 ;
4970 PyObject * obj1 = 0 ;
4971 char *kwnames[] = {
4972 (char *) "self",(char *) "x", NULL
4973 };
4974
4975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4977 if (SWIG_arg_fail(1)) SWIG_fail;
4978 {
4979 arg2 = (int)(SWIG_As_int(obj1));
4980 if (SWIG_arg_fail(2)) SWIG_fail;
4981 }
4982 {
4983 PyThreadState* __tstate = wxPyBeginAllowThreads();
4984 (arg1)->SetX(arg2);
4985
4986 wxPyEndAllowThreads(__tstate);
4987 if (PyErr_Occurred()) SWIG_fail;
4988 }
4989 Py_INCREF(Py_None); resultobj = Py_None;
4990 return resultobj;
4991 fail:
4992 return NULL;
4993 }
4994
4995
4996 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4997 PyObject *resultobj;
4998 wxRect *arg1 = (wxRect *) 0 ;
4999 int result;
5000 PyObject * obj0 = 0 ;
5001 char *kwnames[] = {
5002 (char *) "self", NULL
5003 };
5004
5005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5007 if (SWIG_arg_fail(1)) SWIG_fail;
5008 {
5009 PyThreadState* __tstate = wxPyBeginAllowThreads();
5010 result = (int)(arg1)->GetY();
5011
5012 wxPyEndAllowThreads(__tstate);
5013 if (PyErr_Occurred()) SWIG_fail;
5014 }
5015 {
5016 resultobj = SWIG_From_int((int)(result));
5017 }
5018 return resultobj;
5019 fail:
5020 return NULL;
5021 }
5022
5023
5024 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5025 PyObject *resultobj;
5026 wxRect *arg1 = (wxRect *) 0 ;
5027 int arg2 ;
5028 PyObject * obj0 = 0 ;
5029 PyObject * obj1 = 0 ;
5030 char *kwnames[] = {
5031 (char *) "self",(char *) "y", NULL
5032 };
5033
5034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5036 if (SWIG_arg_fail(1)) SWIG_fail;
5037 {
5038 arg2 = (int)(SWIG_As_int(obj1));
5039 if (SWIG_arg_fail(2)) SWIG_fail;
5040 }
5041 {
5042 PyThreadState* __tstate = wxPyBeginAllowThreads();
5043 (arg1)->SetY(arg2);
5044
5045 wxPyEndAllowThreads(__tstate);
5046 if (PyErr_Occurred()) SWIG_fail;
5047 }
5048 Py_INCREF(Py_None); resultobj = Py_None;
5049 return resultobj;
5050 fail:
5051 return NULL;
5052 }
5053
5054
5055 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5056 PyObject *resultobj;
5057 wxRect *arg1 = (wxRect *) 0 ;
5058 int result;
5059 PyObject * obj0 = 0 ;
5060 char *kwnames[] = {
5061 (char *) "self", NULL
5062 };
5063
5064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5066 if (SWIG_arg_fail(1)) SWIG_fail;
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = (int)((wxRect const *)arg1)->GetWidth();
5070
5071 wxPyEndAllowThreads(__tstate);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 {
5075 resultobj = SWIG_From_int((int)(result));
5076 }
5077 return resultobj;
5078 fail:
5079 return NULL;
5080 }
5081
5082
5083 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5084 PyObject *resultobj;
5085 wxRect *arg1 = (wxRect *) 0 ;
5086 int arg2 ;
5087 PyObject * obj0 = 0 ;
5088 PyObject * obj1 = 0 ;
5089 char *kwnames[] = {
5090 (char *) "self",(char *) "w", NULL
5091 };
5092
5093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5095 if (SWIG_arg_fail(1)) SWIG_fail;
5096 {
5097 arg2 = (int)(SWIG_As_int(obj1));
5098 if (SWIG_arg_fail(2)) SWIG_fail;
5099 }
5100 {
5101 PyThreadState* __tstate = wxPyBeginAllowThreads();
5102 (arg1)->SetWidth(arg2);
5103
5104 wxPyEndAllowThreads(__tstate);
5105 if (PyErr_Occurred()) SWIG_fail;
5106 }
5107 Py_INCREF(Py_None); resultobj = Py_None;
5108 return resultobj;
5109 fail:
5110 return NULL;
5111 }
5112
5113
5114 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5115 PyObject *resultobj;
5116 wxRect *arg1 = (wxRect *) 0 ;
5117 int result;
5118 PyObject * obj0 = 0 ;
5119 char *kwnames[] = {
5120 (char *) "self", NULL
5121 };
5122
5123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5125 if (SWIG_arg_fail(1)) SWIG_fail;
5126 {
5127 PyThreadState* __tstate = wxPyBeginAllowThreads();
5128 result = (int)((wxRect const *)arg1)->GetHeight();
5129
5130 wxPyEndAllowThreads(__tstate);
5131 if (PyErr_Occurred()) SWIG_fail;
5132 }
5133 {
5134 resultobj = SWIG_From_int((int)(result));
5135 }
5136 return resultobj;
5137 fail:
5138 return NULL;
5139 }
5140
5141
5142 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5143 PyObject *resultobj;
5144 wxRect *arg1 = (wxRect *) 0 ;
5145 int arg2 ;
5146 PyObject * obj0 = 0 ;
5147 PyObject * obj1 = 0 ;
5148 char *kwnames[] = {
5149 (char *) "self",(char *) "h", NULL
5150 };
5151
5152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5154 if (SWIG_arg_fail(1)) SWIG_fail;
5155 {
5156 arg2 = (int)(SWIG_As_int(obj1));
5157 if (SWIG_arg_fail(2)) SWIG_fail;
5158 }
5159 {
5160 PyThreadState* __tstate = wxPyBeginAllowThreads();
5161 (arg1)->SetHeight(arg2);
5162
5163 wxPyEndAllowThreads(__tstate);
5164 if (PyErr_Occurred()) SWIG_fail;
5165 }
5166 Py_INCREF(Py_None); resultobj = Py_None;
5167 return resultobj;
5168 fail:
5169 return NULL;
5170 }
5171
5172
5173 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5174 PyObject *resultobj;
5175 wxRect *arg1 = (wxRect *) 0 ;
5176 wxPoint result;
5177 PyObject * obj0 = 0 ;
5178 char *kwnames[] = {
5179 (char *) "self", NULL
5180 };
5181
5182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5184 if (SWIG_arg_fail(1)) SWIG_fail;
5185 {
5186 PyThreadState* __tstate = wxPyBeginAllowThreads();
5187 result = ((wxRect const *)arg1)->GetPosition();
5188
5189 wxPyEndAllowThreads(__tstate);
5190 if (PyErr_Occurred()) SWIG_fail;
5191 }
5192 {
5193 wxPoint * resultptr;
5194 resultptr = new wxPoint((wxPoint &)(result));
5195 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5196 }
5197 return resultobj;
5198 fail:
5199 return NULL;
5200 }
5201
5202
5203 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5204 PyObject *resultobj;
5205 wxRect *arg1 = (wxRect *) 0 ;
5206 wxPoint *arg2 = 0 ;
5207 wxPoint temp2 ;
5208 PyObject * obj0 = 0 ;
5209 PyObject * obj1 = 0 ;
5210 char *kwnames[] = {
5211 (char *) "self",(char *) "p", NULL
5212 };
5213
5214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5216 if (SWIG_arg_fail(1)) SWIG_fail;
5217 {
5218 arg2 = &temp2;
5219 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5220 }
5221 {
5222 PyThreadState* __tstate = wxPyBeginAllowThreads();
5223 (arg1)->SetPosition((wxPoint const &)*arg2);
5224
5225 wxPyEndAllowThreads(__tstate);
5226 if (PyErr_Occurred()) SWIG_fail;
5227 }
5228 Py_INCREF(Py_None); resultobj = Py_None;
5229 return resultobj;
5230 fail:
5231 return NULL;
5232 }
5233
5234
5235 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5236 PyObject *resultobj;
5237 wxRect *arg1 = (wxRect *) 0 ;
5238 wxSize result;
5239 PyObject * obj0 = 0 ;
5240 char *kwnames[] = {
5241 (char *) "self", NULL
5242 };
5243
5244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5246 if (SWIG_arg_fail(1)) SWIG_fail;
5247 {
5248 PyThreadState* __tstate = wxPyBeginAllowThreads();
5249 result = ((wxRect const *)arg1)->GetSize();
5250
5251 wxPyEndAllowThreads(__tstate);
5252 if (PyErr_Occurred()) SWIG_fail;
5253 }
5254 {
5255 wxSize * resultptr;
5256 resultptr = new wxSize((wxSize &)(result));
5257 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5258 }
5259 return resultobj;
5260 fail:
5261 return NULL;
5262 }
5263
5264
5265 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5266 PyObject *resultobj;
5267 wxRect *arg1 = (wxRect *) 0 ;
5268 wxSize *arg2 = 0 ;
5269 wxSize temp2 ;
5270 PyObject * obj0 = 0 ;
5271 PyObject * obj1 = 0 ;
5272 char *kwnames[] = {
5273 (char *) "self",(char *) "s", NULL
5274 };
5275
5276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5278 if (SWIG_arg_fail(1)) SWIG_fail;
5279 {
5280 arg2 = &temp2;
5281 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5282 }
5283 {
5284 PyThreadState* __tstate = wxPyBeginAllowThreads();
5285 (arg1)->SetSize((wxSize const &)*arg2);
5286
5287 wxPyEndAllowThreads(__tstate);
5288 if (PyErr_Occurred()) SWIG_fail;
5289 }
5290 Py_INCREF(Py_None); resultobj = Py_None;
5291 return resultobj;
5292 fail:
5293 return NULL;
5294 }
5295
5296
5297 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5298 PyObject *resultobj;
5299 wxRect *arg1 = (wxRect *) 0 ;
5300 wxPoint result;
5301 PyObject * obj0 = 0 ;
5302 char *kwnames[] = {
5303 (char *) "self", NULL
5304 };
5305
5306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5308 if (SWIG_arg_fail(1)) SWIG_fail;
5309 {
5310 PyThreadState* __tstate = wxPyBeginAllowThreads();
5311 result = ((wxRect const *)arg1)->GetTopLeft();
5312
5313 wxPyEndAllowThreads(__tstate);
5314 if (PyErr_Occurred()) SWIG_fail;
5315 }
5316 {
5317 wxPoint * resultptr;
5318 resultptr = new wxPoint((wxPoint &)(result));
5319 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5320 }
5321 return resultobj;
5322 fail:
5323 return NULL;
5324 }
5325
5326
5327 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5328 PyObject *resultobj;
5329 wxRect *arg1 = (wxRect *) 0 ;
5330 wxPoint *arg2 = 0 ;
5331 wxPoint temp2 ;
5332 PyObject * obj0 = 0 ;
5333 PyObject * obj1 = 0 ;
5334 char *kwnames[] = {
5335 (char *) "self",(char *) "p", NULL
5336 };
5337
5338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5340 if (SWIG_arg_fail(1)) SWIG_fail;
5341 {
5342 arg2 = &temp2;
5343 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5344 }
5345 {
5346 PyThreadState* __tstate = wxPyBeginAllowThreads();
5347 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5348
5349 wxPyEndAllowThreads(__tstate);
5350 if (PyErr_Occurred()) SWIG_fail;
5351 }
5352 Py_INCREF(Py_None); resultobj = Py_None;
5353 return resultobj;
5354 fail:
5355 return NULL;
5356 }
5357
5358
5359 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5360 PyObject *resultobj;
5361 wxRect *arg1 = (wxRect *) 0 ;
5362 wxPoint result;
5363 PyObject * obj0 = 0 ;
5364 char *kwnames[] = {
5365 (char *) "self", NULL
5366 };
5367
5368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5370 if (SWIG_arg_fail(1)) SWIG_fail;
5371 {
5372 PyThreadState* __tstate = wxPyBeginAllowThreads();
5373 result = ((wxRect const *)arg1)->GetBottomRight();
5374
5375 wxPyEndAllowThreads(__tstate);
5376 if (PyErr_Occurred()) SWIG_fail;
5377 }
5378 {
5379 wxPoint * resultptr;
5380 resultptr = new wxPoint((wxPoint &)(result));
5381 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5382 }
5383 return resultobj;
5384 fail:
5385 return NULL;
5386 }
5387
5388
5389 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5390 PyObject *resultobj;
5391 wxRect *arg1 = (wxRect *) 0 ;
5392 wxPoint *arg2 = 0 ;
5393 wxPoint temp2 ;
5394 PyObject * obj0 = 0 ;
5395 PyObject * obj1 = 0 ;
5396 char *kwnames[] = {
5397 (char *) "self",(char *) "p", NULL
5398 };
5399
5400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5402 if (SWIG_arg_fail(1)) SWIG_fail;
5403 {
5404 arg2 = &temp2;
5405 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5406 }
5407 {
5408 PyThreadState* __tstate = wxPyBeginAllowThreads();
5409 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5410
5411 wxPyEndAllowThreads(__tstate);
5412 if (PyErr_Occurred()) SWIG_fail;
5413 }
5414 Py_INCREF(Py_None); resultobj = Py_None;
5415 return resultobj;
5416 fail:
5417 return NULL;
5418 }
5419
5420
5421 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5422 PyObject *resultobj;
5423 wxRect *arg1 = (wxRect *) 0 ;
5424 int result;
5425 PyObject * obj0 = 0 ;
5426 char *kwnames[] = {
5427 (char *) "self", NULL
5428 };
5429
5430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5432 if (SWIG_arg_fail(1)) SWIG_fail;
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = (int)((wxRect const *)arg1)->GetLeft();
5436
5437 wxPyEndAllowThreads(__tstate);
5438 if (PyErr_Occurred()) SWIG_fail;
5439 }
5440 {
5441 resultobj = SWIG_From_int((int)(result));
5442 }
5443 return resultobj;
5444 fail:
5445 return NULL;
5446 }
5447
5448
5449 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5450 PyObject *resultobj;
5451 wxRect *arg1 = (wxRect *) 0 ;
5452 int result;
5453 PyObject * obj0 = 0 ;
5454 char *kwnames[] = {
5455 (char *) "self", NULL
5456 };
5457
5458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5460 if (SWIG_arg_fail(1)) SWIG_fail;
5461 {
5462 PyThreadState* __tstate = wxPyBeginAllowThreads();
5463 result = (int)((wxRect const *)arg1)->GetTop();
5464
5465 wxPyEndAllowThreads(__tstate);
5466 if (PyErr_Occurred()) SWIG_fail;
5467 }
5468 {
5469 resultobj = SWIG_From_int((int)(result));
5470 }
5471 return resultobj;
5472 fail:
5473 return NULL;
5474 }
5475
5476
5477 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5478 PyObject *resultobj;
5479 wxRect *arg1 = (wxRect *) 0 ;
5480 int result;
5481 PyObject * obj0 = 0 ;
5482 char *kwnames[] = {
5483 (char *) "self", NULL
5484 };
5485
5486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5488 if (SWIG_arg_fail(1)) SWIG_fail;
5489 {
5490 PyThreadState* __tstate = wxPyBeginAllowThreads();
5491 result = (int)((wxRect const *)arg1)->GetBottom();
5492
5493 wxPyEndAllowThreads(__tstate);
5494 if (PyErr_Occurred()) SWIG_fail;
5495 }
5496 {
5497 resultobj = SWIG_From_int((int)(result));
5498 }
5499 return resultobj;
5500 fail:
5501 return NULL;
5502 }
5503
5504
5505 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5506 PyObject *resultobj;
5507 wxRect *arg1 = (wxRect *) 0 ;
5508 int result;
5509 PyObject * obj0 = 0 ;
5510 char *kwnames[] = {
5511 (char *) "self", NULL
5512 };
5513
5514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5516 if (SWIG_arg_fail(1)) SWIG_fail;
5517 {
5518 PyThreadState* __tstate = wxPyBeginAllowThreads();
5519 result = (int)((wxRect const *)arg1)->GetRight();
5520
5521 wxPyEndAllowThreads(__tstate);
5522 if (PyErr_Occurred()) SWIG_fail;
5523 }
5524 {
5525 resultobj = SWIG_From_int((int)(result));
5526 }
5527 return resultobj;
5528 fail:
5529 return NULL;
5530 }
5531
5532
5533 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5534 PyObject *resultobj;
5535 wxRect *arg1 = (wxRect *) 0 ;
5536 int arg2 ;
5537 PyObject * obj0 = 0 ;
5538 PyObject * obj1 = 0 ;
5539 char *kwnames[] = {
5540 (char *) "self",(char *) "left", NULL
5541 };
5542
5543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5545 if (SWIG_arg_fail(1)) SWIG_fail;
5546 {
5547 arg2 = (int)(SWIG_As_int(obj1));
5548 if (SWIG_arg_fail(2)) SWIG_fail;
5549 }
5550 {
5551 PyThreadState* __tstate = wxPyBeginAllowThreads();
5552 (arg1)->SetLeft(arg2);
5553
5554 wxPyEndAllowThreads(__tstate);
5555 if (PyErr_Occurred()) SWIG_fail;
5556 }
5557 Py_INCREF(Py_None); resultobj = Py_None;
5558 return resultobj;
5559 fail:
5560 return NULL;
5561 }
5562
5563
5564 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5565 PyObject *resultobj;
5566 wxRect *arg1 = (wxRect *) 0 ;
5567 int arg2 ;
5568 PyObject * obj0 = 0 ;
5569 PyObject * obj1 = 0 ;
5570 char *kwnames[] = {
5571 (char *) "self",(char *) "right", NULL
5572 };
5573
5574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5576 if (SWIG_arg_fail(1)) SWIG_fail;
5577 {
5578 arg2 = (int)(SWIG_As_int(obj1));
5579 if (SWIG_arg_fail(2)) SWIG_fail;
5580 }
5581 {
5582 PyThreadState* __tstate = wxPyBeginAllowThreads();
5583 (arg1)->SetRight(arg2);
5584
5585 wxPyEndAllowThreads(__tstate);
5586 if (PyErr_Occurred()) SWIG_fail;
5587 }
5588 Py_INCREF(Py_None); resultobj = Py_None;
5589 return resultobj;
5590 fail:
5591 return NULL;
5592 }
5593
5594
5595 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5596 PyObject *resultobj;
5597 wxRect *arg1 = (wxRect *) 0 ;
5598 int arg2 ;
5599 PyObject * obj0 = 0 ;
5600 PyObject * obj1 = 0 ;
5601 char *kwnames[] = {
5602 (char *) "self",(char *) "top", NULL
5603 };
5604
5605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5607 if (SWIG_arg_fail(1)) SWIG_fail;
5608 {
5609 arg2 = (int)(SWIG_As_int(obj1));
5610 if (SWIG_arg_fail(2)) SWIG_fail;
5611 }
5612 {
5613 PyThreadState* __tstate = wxPyBeginAllowThreads();
5614 (arg1)->SetTop(arg2);
5615
5616 wxPyEndAllowThreads(__tstate);
5617 if (PyErr_Occurred()) SWIG_fail;
5618 }
5619 Py_INCREF(Py_None); resultobj = Py_None;
5620 return resultobj;
5621 fail:
5622 return NULL;
5623 }
5624
5625
5626 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5627 PyObject *resultobj;
5628 wxRect *arg1 = (wxRect *) 0 ;
5629 int arg2 ;
5630 PyObject * obj0 = 0 ;
5631 PyObject * obj1 = 0 ;
5632 char *kwnames[] = {
5633 (char *) "self",(char *) "bottom", NULL
5634 };
5635
5636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5638 if (SWIG_arg_fail(1)) SWIG_fail;
5639 {
5640 arg2 = (int)(SWIG_As_int(obj1));
5641 if (SWIG_arg_fail(2)) SWIG_fail;
5642 }
5643 {
5644 PyThreadState* __tstate = wxPyBeginAllowThreads();
5645 (arg1)->SetBottom(arg2);
5646
5647 wxPyEndAllowThreads(__tstate);
5648 if (PyErr_Occurred()) SWIG_fail;
5649 }
5650 Py_INCREF(Py_None); resultobj = Py_None;
5651 return resultobj;
5652 fail:
5653 return NULL;
5654 }
5655
5656
5657 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5658 PyObject *resultobj;
5659 wxRect *arg1 = (wxRect *) 0 ;
5660 int arg2 ;
5661 int arg3 ;
5662 wxRect *result;
5663 PyObject * obj0 = 0 ;
5664 PyObject * obj1 = 0 ;
5665 PyObject * obj2 = 0 ;
5666 char *kwnames[] = {
5667 (char *) "self",(char *) "dx",(char *) "dy", NULL
5668 };
5669
5670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5672 if (SWIG_arg_fail(1)) SWIG_fail;
5673 {
5674 arg2 = (int)(SWIG_As_int(obj1));
5675 if (SWIG_arg_fail(2)) SWIG_fail;
5676 }
5677 {
5678 arg3 = (int)(SWIG_As_int(obj2));
5679 if (SWIG_arg_fail(3)) SWIG_fail;
5680 }
5681 {
5682 PyThreadState* __tstate = wxPyBeginAllowThreads();
5683 {
5684 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5685 result = (wxRect *) &_result_ref;
5686 }
5687
5688 wxPyEndAllowThreads(__tstate);
5689 if (PyErr_Occurred()) SWIG_fail;
5690 }
5691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5692 return resultobj;
5693 fail:
5694 return NULL;
5695 }
5696
5697
5698 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5699 PyObject *resultobj;
5700 wxRect *arg1 = (wxRect *) 0 ;
5701 int arg2 ;
5702 int arg3 ;
5703 wxRect *result;
5704 PyObject * obj0 = 0 ;
5705 PyObject * obj1 = 0 ;
5706 PyObject * obj2 = 0 ;
5707 char *kwnames[] = {
5708 (char *) "self",(char *) "dx",(char *) "dy", NULL
5709 };
5710
5711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5713 if (SWIG_arg_fail(1)) SWIG_fail;
5714 {
5715 arg2 = (int)(SWIG_As_int(obj1));
5716 if (SWIG_arg_fail(2)) SWIG_fail;
5717 }
5718 {
5719 arg3 = (int)(SWIG_As_int(obj2));
5720 if (SWIG_arg_fail(3)) SWIG_fail;
5721 }
5722 {
5723 PyThreadState* __tstate = wxPyBeginAllowThreads();
5724 {
5725 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5726 result = (wxRect *) &_result_ref;
5727 }
5728
5729 wxPyEndAllowThreads(__tstate);
5730 if (PyErr_Occurred()) SWIG_fail;
5731 }
5732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5733 return resultobj;
5734 fail:
5735 return NULL;
5736 }
5737
5738
5739 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5740 PyObject *resultobj;
5741 wxRect *arg1 = (wxRect *) 0 ;
5742 int arg2 ;
5743 int arg3 ;
5744 PyObject * obj0 = 0 ;
5745 PyObject * obj1 = 0 ;
5746 PyObject * obj2 = 0 ;
5747 char *kwnames[] = {
5748 (char *) "self",(char *) "dx",(char *) "dy", NULL
5749 };
5750
5751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5753 if (SWIG_arg_fail(1)) SWIG_fail;
5754 {
5755 arg2 = (int)(SWIG_As_int(obj1));
5756 if (SWIG_arg_fail(2)) SWIG_fail;
5757 }
5758 {
5759 arg3 = (int)(SWIG_As_int(obj2));
5760 if (SWIG_arg_fail(3)) SWIG_fail;
5761 }
5762 {
5763 PyThreadState* __tstate = wxPyBeginAllowThreads();
5764 (arg1)->Offset(arg2,arg3);
5765
5766 wxPyEndAllowThreads(__tstate);
5767 if (PyErr_Occurred()) SWIG_fail;
5768 }
5769 Py_INCREF(Py_None); resultobj = Py_None;
5770 return resultobj;
5771 fail:
5772 return NULL;
5773 }
5774
5775
5776 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj;
5778 wxRect *arg1 = (wxRect *) 0 ;
5779 wxPoint *arg2 = 0 ;
5780 wxPoint temp2 ;
5781 PyObject * obj0 = 0 ;
5782 PyObject * obj1 = 0 ;
5783 char *kwnames[] = {
5784 (char *) "self",(char *) "pt", NULL
5785 };
5786
5787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5789 if (SWIG_arg_fail(1)) SWIG_fail;
5790 {
5791 arg2 = &temp2;
5792 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5793 }
5794 {
5795 PyThreadState* __tstate = wxPyBeginAllowThreads();
5796 (arg1)->Offset((wxPoint const &)*arg2);
5797
5798 wxPyEndAllowThreads(__tstate);
5799 if (PyErr_Occurred()) SWIG_fail;
5800 }
5801 Py_INCREF(Py_None); resultobj = Py_None;
5802 return resultobj;
5803 fail:
5804 return NULL;
5805 }
5806
5807
5808 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5809 PyObject *resultobj;
5810 wxRect *arg1 = (wxRect *) 0 ;
5811 wxRect *arg2 = 0 ;
5812 wxRect result;
5813 wxRect temp2 ;
5814 PyObject * obj0 = 0 ;
5815 PyObject * obj1 = 0 ;
5816 char *kwnames[] = {
5817 (char *) "self",(char *) "rect", NULL
5818 };
5819
5820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5822 if (SWIG_arg_fail(1)) SWIG_fail;
5823 {
5824 arg2 = &temp2;
5825 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5826 }
5827 {
5828 PyThreadState* __tstate = wxPyBeginAllowThreads();
5829 result = (arg1)->Intersect((wxRect const &)*arg2);
5830
5831 wxPyEndAllowThreads(__tstate);
5832 if (PyErr_Occurred()) SWIG_fail;
5833 }
5834 {
5835 wxRect * resultptr;
5836 resultptr = new wxRect((wxRect &)(result));
5837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5838 }
5839 return resultobj;
5840 fail:
5841 return NULL;
5842 }
5843
5844
5845 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj;
5847 wxRect *arg1 = (wxRect *) 0 ;
5848 wxRect *arg2 = 0 ;
5849 wxRect result;
5850 wxRect temp2 ;
5851 PyObject * obj0 = 0 ;
5852 PyObject * obj1 = 0 ;
5853 char *kwnames[] = {
5854 (char *) "self",(char *) "rect", NULL
5855 };
5856
5857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5859 if (SWIG_arg_fail(1)) SWIG_fail;
5860 {
5861 arg2 = &temp2;
5862 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5863 }
5864 {
5865 PyThreadState* __tstate = wxPyBeginAllowThreads();
5866 result = (arg1)->Union((wxRect const &)*arg2);
5867
5868 wxPyEndAllowThreads(__tstate);
5869 if (PyErr_Occurred()) SWIG_fail;
5870 }
5871 {
5872 wxRect * resultptr;
5873 resultptr = new wxRect((wxRect &)(result));
5874 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5875 }
5876 return resultobj;
5877 fail:
5878 return NULL;
5879 }
5880
5881
5882 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5883 PyObject *resultobj;
5884 wxRect *arg1 = (wxRect *) 0 ;
5885 wxRect *arg2 = 0 ;
5886 wxRect result;
5887 wxRect temp2 ;
5888 PyObject * obj0 = 0 ;
5889 PyObject * obj1 = 0 ;
5890 char *kwnames[] = {
5891 (char *) "self",(char *) "rect", NULL
5892 };
5893
5894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5896 if (SWIG_arg_fail(1)) SWIG_fail;
5897 {
5898 arg2 = &temp2;
5899 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5900 }
5901 {
5902 PyThreadState* __tstate = wxPyBeginAllowThreads();
5903 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5904
5905 wxPyEndAllowThreads(__tstate);
5906 if (PyErr_Occurred()) SWIG_fail;
5907 }
5908 {
5909 wxRect * resultptr;
5910 resultptr = new wxRect((wxRect &)(result));
5911 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5912 }
5913 return resultobj;
5914 fail:
5915 return NULL;
5916 }
5917
5918
5919 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5920 PyObject *resultobj;
5921 wxRect *arg1 = (wxRect *) 0 ;
5922 wxRect *arg2 = 0 ;
5923 wxRect *result;
5924 wxRect temp2 ;
5925 PyObject * obj0 = 0 ;
5926 PyObject * obj1 = 0 ;
5927 char *kwnames[] = {
5928 (char *) "self",(char *) "rect", NULL
5929 };
5930
5931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5933 if (SWIG_arg_fail(1)) SWIG_fail;
5934 {
5935 arg2 = &temp2;
5936 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5937 }
5938 {
5939 PyThreadState* __tstate = wxPyBeginAllowThreads();
5940 {
5941 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5942 result = (wxRect *) &_result_ref;
5943 }
5944
5945 wxPyEndAllowThreads(__tstate);
5946 if (PyErr_Occurred()) SWIG_fail;
5947 }
5948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5949 return resultobj;
5950 fail:
5951 return NULL;
5952 }
5953
5954
5955 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5956 PyObject *resultobj;
5957 wxRect *arg1 = (wxRect *) 0 ;
5958 wxRect *arg2 = 0 ;
5959 bool result;
5960 wxRect temp2 ;
5961 PyObject * obj0 = 0 ;
5962 PyObject * obj1 = 0 ;
5963 char *kwnames[] = {
5964 (char *) "self",(char *) "rect", NULL
5965 };
5966
5967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5969 if (SWIG_arg_fail(1)) SWIG_fail;
5970 {
5971 arg2 = &temp2;
5972 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5973 }
5974 {
5975 PyThreadState* __tstate = wxPyBeginAllowThreads();
5976 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5977
5978 wxPyEndAllowThreads(__tstate);
5979 if (PyErr_Occurred()) SWIG_fail;
5980 }
5981 {
5982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5983 }
5984 return resultobj;
5985 fail:
5986 return NULL;
5987 }
5988
5989
5990 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5991 PyObject *resultobj;
5992 wxRect *arg1 = (wxRect *) 0 ;
5993 wxRect *arg2 = 0 ;
5994 bool result;
5995 wxRect temp2 ;
5996 PyObject * obj0 = 0 ;
5997 PyObject * obj1 = 0 ;
5998 char *kwnames[] = {
5999 (char *) "self",(char *) "rect", NULL
6000 };
6001
6002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6004 if (SWIG_arg_fail(1)) SWIG_fail;
6005 {
6006 arg2 = &temp2;
6007 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6008 }
6009 {
6010 PyThreadState* __tstate = wxPyBeginAllowThreads();
6011 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6012
6013 wxPyEndAllowThreads(__tstate);
6014 if (PyErr_Occurred()) SWIG_fail;
6015 }
6016 {
6017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6018 }
6019 return resultobj;
6020 fail:
6021 return NULL;
6022 }
6023
6024
6025 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6026 PyObject *resultobj;
6027 wxRect *arg1 = (wxRect *) 0 ;
6028 int arg2 ;
6029 int arg3 ;
6030 bool result;
6031 PyObject * obj0 = 0 ;
6032 PyObject * obj1 = 0 ;
6033 PyObject * obj2 = 0 ;
6034 char *kwnames[] = {
6035 (char *) "self",(char *) "x",(char *) "y", NULL
6036 };
6037
6038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6040 if (SWIG_arg_fail(1)) SWIG_fail;
6041 {
6042 arg2 = (int)(SWIG_As_int(obj1));
6043 if (SWIG_arg_fail(2)) SWIG_fail;
6044 }
6045 {
6046 arg3 = (int)(SWIG_As_int(obj2));
6047 if (SWIG_arg_fail(3)) SWIG_fail;
6048 }
6049 {
6050 PyThreadState* __tstate = wxPyBeginAllowThreads();
6051 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6052
6053 wxPyEndAllowThreads(__tstate);
6054 if (PyErr_Occurred()) SWIG_fail;
6055 }
6056 {
6057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6058 }
6059 return resultobj;
6060 fail:
6061 return NULL;
6062 }
6063
6064
6065 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6066 PyObject *resultobj;
6067 wxRect *arg1 = (wxRect *) 0 ;
6068 wxPoint *arg2 = 0 ;
6069 bool result;
6070 wxPoint temp2 ;
6071 PyObject * obj0 = 0 ;
6072 PyObject * obj1 = 0 ;
6073 char *kwnames[] = {
6074 (char *) "self",(char *) "pt", NULL
6075 };
6076
6077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6079 if (SWIG_arg_fail(1)) SWIG_fail;
6080 {
6081 arg2 = &temp2;
6082 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6083 }
6084 {
6085 PyThreadState* __tstate = wxPyBeginAllowThreads();
6086 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6087
6088 wxPyEndAllowThreads(__tstate);
6089 if (PyErr_Occurred()) SWIG_fail;
6090 }
6091 {
6092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6093 }
6094 return resultobj;
6095 fail:
6096 return NULL;
6097 }
6098
6099
6100 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6101 PyObject *resultobj;
6102 wxRect *arg1 = (wxRect *) 0 ;
6103 wxRect *arg2 = 0 ;
6104 bool result;
6105 wxRect temp2 ;
6106 PyObject * obj0 = 0 ;
6107 PyObject * obj1 = 0 ;
6108 char *kwnames[] = {
6109 (char *) "self",(char *) "rect", NULL
6110 };
6111
6112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6114 if (SWIG_arg_fail(1)) SWIG_fail;
6115 {
6116 arg2 = &temp2;
6117 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6118 }
6119 {
6120 PyThreadState* __tstate = wxPyBeginAllowThreads();
6121 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6122
6123 wxPyEndAllowThreads(__tstate);
6124 if (PyErr_Occurred()) SWIG_fail;
6125 }
6126 {
6127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6128 }
6129 return resultobj;
6130 fail:
6131 return NULL;
6132 }
6133
6134
6135 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6136 PyObject *resultobj;
6137 wxRect *arg1 = (wxRect *) 0 ;
6138 int arg2 ;
6139 PyObject * obj0 = 0 ;
6140 PyObject * obj1 = 0 ;
6141 char *kwnames[] = {
6142 (char *) "self",(char *) "x", NULL
6143 };
6144
6145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6147 if (SWIG_arg_fail(1)) SWIG_fail;
6148 {
6149 arg2 = (int)(SWIG_As_int(obj1));
6150 if (SWIG_arg_fail(2)) SWIG_fail;
6151 }
6152 if (arg1) (arg1)->x = arg2;
6153
6154 Py_INCREF(Py_None); resultobj = Py_None;
6155 return resultobj;
6156 fail:
6157 return NULL;
6158 }
6159
6160
6161 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6162 PyObject *resultobj;
6163 wxRect *arg1 = (wxRect *) 0 ;
6164 int result;
6165 PyObject * obj0 = 0 ;
6166 char *kwnames[] = {
6167 (char *) "self", NULL
6168 };
6169
6170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6172 if (SWIG_arg_fail(1)) SWIG_fail;
6173 result = (int) ((arg1)->x);
6174
6175 {
6176 resultobj = SWIG_From_int((int)(result));
6177 }
6178 return resultobj;
6179 fail:
6180 return NULL;
6181 }
6182
6183
6184 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6185 PyObject *resultobj;
6186 wxRect *arg1 = (wxRect *) 0 ;
6187 int arg2 ;
6188 PyObject * obj0 = 0 ;
6189 PyObject * obj1 = 0 ;
6190 char *kwnames[] = {
6191 (char *) "self",(char *) "y", NULL
6192 };
6193
6194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6196 if (SWIG_arg_fail(1)) SWIG_fail;
6197 {
6198 arg2 = (int)(SWIG_As_int(obj1));
6199 if (SWIG_arg_fail(2)) SWIG_fail;
6200 }
6201 if (arg1) (arg1)->y = arg2;
6202
6203 Py_INCREF(Py_None); resultobj = Py_None;
6204 return resultobj;
6205 fail:
6206 return NULL;
6207 }
6208
6209
6210 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6211 PyObject *resultobj;
6212 wxRect *arg1 = (wxRect *) 0 ;
6213 int result;
6214 PyObject * obj0 = 0 ;
6215 char *kwnames[] = {
6216 (char *) "self", NULL
6217 };
6218
6219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6221 if (SWIG_arg_fail(1)) SWIG_fail;
6222 result = (int) ((arg1)->y);
6223
6224 {
6225 resultobj = SWIG_From_int((int)(result));
6226 }
6227 return resultobj;
6228 fail:
6229 return NULL;
6230 }
6231
6232
6233 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6234 PyObject *resultobj;
6235 wxRect *arg1 = (wxRect *) 0 ;
6236 int arg2 ;
6237 PyObject * obj0 = 0 ;
6238 PyObject * obj1 = 0 ;
6239 char *kwnames[] = {
6240 (char *) "self",(char *) "width", NULL
6241 };
6242
6243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6245 if (SWIG_arg_fail(1)) SWIG_fail;
6246 {
6247 arg2 = (int)(SWIG_As_int(obj1));
6248 if (SWIG_arg_fail(2)) SWIG_fail;
6249 }
6250 if (arg1) (arg1)->width = arg2;
6251
6252 Py_INCREF(Py_None); resultobj = Py_None;
6253 return resultobj;
6254 fail:
6255 return NULL;
6256 }
6257
6258
6259 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6260 PyObject *resultobj;
6261 wxRect *arg1 = (wxRect *) 0 ;
6262 int result;
6263 PyObject * obj0 = 0 ;
6264 char *kwnames[] = {
6265 (char *) "self", NULL
6266 };
6267
6268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6270 if (SWIG_arg_fail(1)) SWIG_fail;
6271 result = (int) ((arg1)->width);
6272
6273 {
6274 resultobj = SWIG_From_int((int)(result));
6275 }
6276 return resultobj;
6277 fail:
6278 return NULL;
6279 }
6280
6281
6282 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6283 PyObject *resultobj;
6284 wxRect *arg1 = (wxRect *) 0 ;
6285 int arg2 ;
6286 PyObject * obj0 = 0 ;
6287 PyObject * obj1 = 0 ;
6288 char *kwnames[] = {
6289 (char *) "self",(char *) "height", NULL
6290 };
6291
6292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6294 if (SWIG_arg_fail(1)) SWIG_fail;
6295 {
6296 arg2 = (int)(SWIG_As_int(obj1));
6297 if (SWIG_arg_fail(2)) SWIG_fail;
6298 }
6299 if (arg1) (arg1)->height = arg2;
6300
6301 Py_INCREF(Py_None); resultobj = Py_None;
6302 return resultobj;
6303 fail:
6304 return NULL;
6305 }
6306
6307
6308 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6309 PyObject *resultobj;
6310 wxRect *arg1 = (wxRect *) 0 ;
6311 int result;
6312 PyObject * obj0 = 0 ;
6313 char *kwnames[] = {
6314 (char *) "self", NULL
6315 };
6316
6317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6319 if (SWIG_arg_fail(1)) SWIG_fail;
6320 result = (int) ((arg1)->height);
6321
6322 {
6323 resultobj = SWIG_From_int((int)(result));
6324 }
6325 return resultobj;
6326 fail:
6327 return NULL;
6328 }
6329
6330
6331 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6332 PyObject *resultobj;
6333 wxRect *arg1 = (wxRect *) 0 ;
6334 int arg2 = (int) 0 ;
6335 int arg3 = (int) 0 ;
6336 int arg4 = (int) 0 ;
6337 int arg5 = (int) 0 ;
6338 PyObject * obj0 = 0 ;
6339 PyObject * obj1 = 0 ;
6340 PyObject * obj2 = 0 ;
6341 PyObject * obj3 = 0 ;
6342 PyObject * obj4 = 0 ;
6343 char *kwnames[] = {
6344 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6345 };
6346
6347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6349 if (SWIG_arg_fail(1)) SWIG_fail;
6350 if (obj1) {
6351 {
6352 arg2 = (int)(SWIG_As_int(obj1));
6353 if (SWIG_arg_fail(2)) SWIG_fail;
6354 }
6355 }
6356 if (obj2) {
6357 {
6358 arg3 = (int)(SWIG_As_int(obj2));
6359 if (SWIG_arg_fail(3)) SWIG_fail;
6360 }
6361 }
6362 if (obj3) {
6363 {
6364 arg4 = (int)(SWIG_As_int(obj3));
6365 if (SWIG_arg_fail(4)) SWIG_fail;
6366 }
6367 }
6368 if (obj4) {
6369 {
6370 arg5 = (int)(SWIG_As_int(obj4));
6371 if (SWIG_arg_fail(5)) SWIG_fail;
6372 }
6373 }
6374 {
6375 PyThreadState* __tstate = wxPyBeginAllowThreads();
6376 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6377
6378 wxPyEndAllowThreads(__tstate);
6379 if (PyErr_Occurred()) SWIG_fail;
6380 }
6381 Py_INCREF(Py_None); resultobj = Py_None;
6382 return resultobj;
6383 fail:
6384 return NULL;
6385 }
6386
6387
6388 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6389 PyObject *resultobj;
6390 wxRect *arg1 = (wxRect *) 0 ;
6391 PyObject *result;
6392 PyObject * obj0 = 0 ;
6393 char *kwnames[] = {
6394 (char *) "self", NULL
6395 };
6396
6397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6399 if (SWIG_arg_fail(1)) SWIG_fail;
6400 {
6401 PyThreadState* __tstate = wxPyBeginAllowThreads();
6402 result = (PyObject *)wxRect_Get(arg1);
6403
6404 wxPyEndAllowThreads(__tstate);
6405 if (PyErr_Occurred()) SWIG_fail;
6406 }
6407 resultobj = result;
6408 return resultobj;
6409 fail:
6410 return NULL;
6411 }
6412
6413
6414 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6415 PyObject *obj;
6416 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6417 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6418 Py_INCREF(obj);
6419 return Py_BuildValue((char *)"");
6420 }
6421 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6422 PyObject *resultobj;
6423 wxRect *arg1 = (wxRect *) 0 ;
6424 wxRect *arg2 = (wxRect *) 0 ;
6425 PyObject *result;
6426 PyObject * obj0 = 0 ;
6427 PyObject * obj1 = 0 ;
6428 char *kwnames[] = {
6429 (char *) "r1",(char *) "r2", NULL
6430 };
6431
6432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6434 if (SWIG_arg_fail(1)) SWIG_fail;
6435 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6436 if (SWIG_arg_fail(2)) SWIG_fail;
6437 {
6438 if (!wxPyCheckForApp()) SWIG_fail;
6439 PyThreadState* __tstate = wxPyBeginAllowThreads();
6440 result = (PyObject *)wxIntersectRect(arg1,arg2);
6441
6442 wxPyEndAllowThreads(__tstate);
6443 if (PyErr_Occurred()) SWIG_fail;
6444 }
6445 resultobj = result;
6446 return resultobj;
6447 fail:
6448 return NULL;
6449 }
6450
6451
6452 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6453 PyObject *resultobj;
6454 double arg1 = (double) 0.0 ;
6455 double arg2 = (double) 0.0 ;
6456 wxPoint2D *result;
6457 PyObject * obj0 = 0 ;
6458 PyObject * obj1 = 0 ;
6459 char *kwnames[] = {
6460 (char *) "x",(char *) "y", NULL
6461 };
6462
6463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6464 if (obj0) {
6465 {
6466 arg1 = (double)(SWIG_As_double(obj0));
6467 if (SWIG_arg_fail(1)) SWIG_fail;
6468 }
6469 }
6470 if (obj1) {
6471 {
6472 arg2 = (double)(SWIG_As_double(obj1));
6473 if (SWIG_arg_fail(2)) SWIG_fail;
6474 }
6475 }
6476 {
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6479
6480 wxPyEndAllowThreads(__tstate);
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6491 PyObject *resultobj;
6492 wxPoint2D *arg1 = 0 ;
6493 wxPoint2D *result;
6494 wxPoint2D temp1 ;
6495 PyObject * obj0 = 0 ;
6496 char *kwnames[] = {
6497 (char *) "pt", NULL
6498 };
6499
6500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6501 {
6502 arg1 = &temp1;
6503 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6504 }
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6508
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6513 return resultobj;
6514 fail:
6515 return NULL;
6516 }
6517
6518
6519 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6520 PyObject *resultobj;
6521 wxPoint *arg1 = 0 ;
6522 wxPoint2D *result;
6523 wxPoint temp1 ;
6524 PyObject * obj0 = 0 ;
6525 char *kwnames[] = {
6526 (char *) "pt", NULL
6527 };
6528
6529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6530 {
6531 arg1 = &temp1;
6532 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6533 }
6534 {
6535 PyThreadState* __tstate = wxPyBeginAllowThreads();
6536 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6537
6538 wxPyEndAllowThreads(__tstate);
6539 if (PyErr_Occurred()) SWIG_fail;
6540 }
6541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6542 return resultobj;
6543 fail:
6544 return NULL;
6545 }
6546
6547
6548 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6549 PyObject *resultobj;
6550 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6551 int *arg2 = (int *) 0 ;
6552 int *arg3 = (int *) 0 ;
6553 int temp2 ;
6554 int res2 = 0 ;
6555 int temp3 ;
6556 int res3 = 0 ;
6557 PyObject * obj0 = 0 ;
6558 char *kwnames[] = {
6559 (char *) "self", NULL
6560 };
6561
6562 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6563 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6566 if (SWIG_arg_fail(1)) SWIG_fail;
6567 {
6568 PyThreadState* __tstate = wxPyBeginAllowThreads();
6569 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6570
6571 wxPyEndAllowThreads(__tstate);
6572 if (PyErr_Occurred()) SWIG_fail;
6573 }
6574 Py_INCREF(Py_None); resultobj = Py_None;
6575 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6576 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6577 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6578 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6579 return resultobj;
6580 fail:
6581 return NULL;
6582 }
6583
6584
6585 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6586 PyObject *resultobj;
6587 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6588 int *arg2 = (int *) 0 ;
6589 int *arg3 = (int *) 0 ;
6590 int temp2 ;
6591 int res2 = 0 ;
6592 int temp3 ;
6593 int res3 = 0 ;
6594 PyObject * obj0 = 0 ;
6595 char *kwnames[] = {
6596 (char *) "self", NULL
6597 };
6598
6599 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6600 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6603 if (SWIG_arg_fail(1)) SWIG_fail;
6604 {
6605 PyThreadState* __tstate = wxPyBeginAllowThreads();
6606 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6607
6608 wxPyEndAllowThreads(__tstate);
6609 if (PyErr_Occurred()) SWIG_fail;
6610 }
6611 Py_INCREF(Py_None); resultobj = Py_None;
6612 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6613 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6614 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6615 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6616 return resultobj;
6617 fail:
6618 return NULL;
6619 }
6620
6621
6622 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6623 PyObject *resultobj;
6624 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6625 double result;
6626 PyObject * obj0 = 0 ;
6627 char *kwnames[] = {
6628 (char *) "self", NULL
6629 };
6630
6631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6633 if (SWIG_arg_fail(1)) SWIG_fail;
6634 {
6635 PyThreadState* __tstate = wxPyBeginAllowThreads();
6636 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6637
6638 wxPyEndAllowThreads(__tstate);
6639 if (PyErr_Occurred()) SWIG_fail;
6640 }
6641 {
6642 resultobj = SWIG_From_double((double)(result));
6643 }
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6651 PyObject *resultobj;
6652 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6653 double result;
6654 PyObject * obj0 = 0 ;
6655 char *kwnames[] = {
6656 (char *) "self", NULL
6657 };
6658
6659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",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 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6665
6666 wxPyEndAllowThreads(__tstate);
6667 if (PyErr_Occurred()) SWIG_fail;
6668 }
6669 {
6670 resultobj = SWIG_From_double((double)(result));
6671 }
6672 return resultobj;
6673 fail:
6674 return NULL;
6675 }
6676
6677
6678 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6679 PyObject *resultobj;
6680 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6681 double arg2 ;
6682 PyObject * obj0 = 0 ;
6683 PyObject * obj1 = 0 ;
6684 char *kwnames[] = {
6685 (char *) "self",(char *) "length", NULL
6686 };
6687
6688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6690 if (SWIG_arg_fail(1)) SWIG_fail;
6691 {
6692 arg2 = (double)(SWIG_As_double(obj1));
6693 if (SWIG_arg_fail(2)) SWIG_fail;
6694 }
6695 {
6696 PyThreadState* __tstate = wxPyBeginAllowThreads();
6697 (arg1)->SetVectorLength(arg2);
6698
6699 wxPyEndAllowThreads(__tstate);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 Py_INCREF(Py_None); resultobj = Py_None;
6703 return resultobj;
6704 fail:
6705 return NULL;
6706 }
6707
6708
6709 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6710 PyObject *resultobj;
6711 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6712 double arg2 ;
6713 PyObject * obj0 = 0 ;
6714 PyObject * obj1 = 0 ;
6715 char *kwnames[] = {
6716 (char *) "self",(char *) "degrees", NULL
6717 };
6718
6719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6721 if (SWIG_arg_fail(1)) SWIG_fail;
6722 {
6723 arg2 = (double)(SWIG_As_double(obj1));
6724 if (SWIG_arg_fail(2)) SWIG_fail;
6725 }
6726 {
6727 PyThreadState* __tstate = wxPyBeginAllowThreads();
6728 (arg1)->SetVectorAngle(arg2);
6729
6730 wxPyEndAllowThreads(__tstate);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 Py_INCREF(Py_None); resultobj = Py_None;
6734 return resultobj;
6735 fail:
6736 return NULL;
6737 }
6738
6739
6740 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6741 PyObject *resultobj;
6742 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6743 wxPoint2D *arg2 = 0 ;
6744 double result;
6745 wxPoint2D temp2 ;
6746 PyObject * obj0 = 0 ;
6747 PyObject * obj1 = 0 ;
6748 char *kwnames[] = {
6749 (char *) "self",(char *) "pt", NULL
6750 };
6751
6752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6754 if (SWIG_arg_fail(1)) SWIG_fail;
6755 {
6756 arg2 = &temp2;
6757 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6758 }
6759 {
6760 PyThreadState* __tstate = wxPyBeginAllowThreads();
6761 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6762
6763 wxPyEndAllowThreads(__tstate);
6764 if (PyErr_Occurred()) SWIG_fail;
6765 }
6766 {
6767 resultobj = SWIG_From_double((double)(result));
6768 }
6769 return resultobj;
6770 fail:
6771 return NULL;
6772 }
6773
6774
6775 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6776 PyObject *resultobj;
6777 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6778 wxPoint2D *arg2 = 0 ;
6779 double result;
6780 wxPoint2D temp2 ;
6781 PyObject * obj0 = 0 ;
6782 PyObject * obj1 = 0 ;
6783 char *kwnames[] = {
6784 (char *) "self",(char *) "pt", NULL
6785 };
6786
6787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6789 if (SWIG_arg_fail(1)) SWIG_fail;
6790 {
6791 arg2 = &temp2;
6792 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6793 }
6794 {
6795 PyThreadState* __tstate = wxPyBeginAllowThreads();
6796 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6797
6798 wxPyEndAllowThreads(__tstate);
6799 if (PyErr_Occurred()) SWIG_fail;
6800 }
6801 {
6802 resultobj = SWIG_From_double((double)(result));
6803 }
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6811 PyObject *resultobj;
6812 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6813 wxPoint2D *arg2 = 0 ;
6814 double result;
6815 wxPoint2D temp2 ;
6816 PyObject * obj0 = 0 ;
6817 PyObject * obj1 = 0 ;
6818 char *kwnames[] = {
6819 (char *) "self",(char *) "vec", NULL
6820 };
6821
6822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6824 if (SWIG_arg_fail(1)) SWIG_fail;
6825 {
6826 arg2 = &temp2;
6827 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6828 }
6829 {
6830 PyThreadState* __tstate = wxPyBeginAllowThreads();
6831 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6832
6833 wxPyEndAllowThreads(__tstate);
6834 if (PyErr_Occurred()) SWIG_fail;
6835 }
6836 {
6837 resultobj = SWIG_From_double((double)(result));
6838 }
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6846 PyObject *resultobj;
6847 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6848 wxPoint2D *arg2 = 0 ;
6849 double result;
6850 wxPoint2D temp2 ;
6851 PyObject * obj0 = 0 ;
6852 PyObject * obj1 = 0 ;
6853 char *kwnames[] = {
6854 (char *) "self",(char *) "vec", NULL
6855 };
6856
6857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6859 if (SWIG_arg_fail(1)) SWIG_fail;
6860 {
6861 arg2 = &temp2;
6862 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6863 }
6864 {
6865 PyThreadState* __tstate = wxPyBeginAllowThreads();
6866 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6867
6868 wxPyEndAllowThreads(__tstate);
6869 if (PyErr_Occurred()) SWIG_fail;
6870 }
6871 {
6872 resultobj = SWIG_From_double((double)(result));
6873 }
6874 return resultobj;
6875 fail:
6876 return NULL;
6877 }
6878
6879
6880 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6881 PyObject *resultobj;
6882 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6883 wxPoint2D result;
6884 PyObject * obj0 = 0 ;
6885 char *kwnames[] = {
6886 (char *) "self", NULL
6887 };
6888
6889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6891 if (SWIG_arg_fail(1)) SWIG_fail;
6892 {
6893 PyThreadState* __tstate = wxPyBeginAllowThreads();
6894 result = (arg1)->operator -();
6895
6896 wxPyEndAllowThreads(__tstate);
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 {
6900 wxPoint2D * resultptr;
6901 resultptr = new wxPoint2D((wxPoint2D &)(result));
6902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6903 }
6904 return resultobj;
6905 fail:
6906 return NULL;
6907 }
6908
6909
6910 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6911 PyObject *resultobj;
6912 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6913 wxPoint2D *arg2 = 0 ;
6914 wxPoint2D *result;
6915 wxPoint2D temp2 ;
6916 PyObject * obj0 = 0 ;
6917 PyObject * obj1 = 0 ;
6918 char *kwnames[] = {
6919 (char *) "self",(char *) "pt", NULL
6920 };
6921
6922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6924 if (SWIG_arg_fail(1)) SWIG_fail;
6925 {
6926 arg2 = &temp2;
6927 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6928 }
6929 {
6930 PyThreadState* __tstate = wxPyBeginAllowThreads();
6931 {
6932 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6933 result = (wxPoint2D *) &_result_ref;
6934 }
6935
6936 wxPyEndAllowThreads(__tstate);
6937 if (PyErr_Occurred()) SWIG_fail;
6938 }
6939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6940 return resultobj;
6941 fail:
6942 return NULL;
6943 }
6944
6945
6946 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6947 PyObject *resultobj;
6948 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6949 wxPoint2D *arg2 = 0 ;
6950 wxPoint2D *result;
6951 wxPoint2D temp2 ;
6952 PyObject * obj0 = 0 ;
6953 PyObject * obj1 = 0 ;
6954 char *kwnames[] = {
6955 (char *) "self",(char *) "pt", NULL
6956 };
6957
6958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6960 if (SWIG_arg_fail(1)) SWIG_fail;
6961 {
6962 arg2 = &temp2;
6963 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6964 }
6965 {
6966 PyThreadState* __tstate = wxPyBeginAllowThreads();
6967 {
6968 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6969 result = (wxPoint2D *) &_result_ref;
6970 }
6971
6972 wxPyEndAllowThreads(__tstate);
6973 if (PyErr_Occurred()) SWIG_fail;
6974 }
6975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6976 return resultobj;
6977 fail:
6978 return NULL;
6979 }
6980
6981
6982 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6983 PyObject *resultobj;
6984 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6985 wxPoint2D *arg2 = 0 ;
6986 wxPoint2D *result;
6987 wxPoint2D temp2 ;
6988 PyObject * obj0 = 0 ;
6989 PyObject * obj1 = 0 ;
6990 char *kwnames[] = {
6991 (char *) "self",(char *) "pt", NULL
6992 };
6993
6994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6996 if (SWIG_arg_fail(1)) SWIG_fail;
6997 {
6998 arg2 = &temp2;
6999 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7000 }
7001 {
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 {
7004 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7005 result = (wxPoint2D *) &_result_ref;
7006 }
7007
7008 wxPyEndAllowThreads(__tstate);
7009 if (PyErr_Occurred()) SWIG_fail;
7010 }
7011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7012 return resultobj;
7013 fail:
7014 return NULL;
7015 }
7016
7017
7018 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7019 PyObject *resultobj;
7020 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7021 wxPoint2D *arg2 = 0 ;
7022 wxPoint2D *result;
7023 wxPoint2D temp2 ;
7024 PyObject * obj0 = 0 ;
7025 PyObject * obj1 = 0 ;
7026 char *kwnames[] = {
7027 (char *) "self",(char *) "pt", NULL
7028 };
7029
7030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7032 if (SWIG_arg_fail(1)) SWIG_fail;
7033 {
7034 arg2 = &temp2;
7035 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7036 }
7037 {
7038 PyThreadState* __tstate = wxPyBeginAllowThreads();
7039 {
7040 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7041 result = (wxPoint2D *) &_result_ref;
7042 }
7043
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7048 return resultobj;
7049 fail:
7050 return NULL;
7051 }
7052
7053
7054 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7055 PyObject *resultobj;
7056 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7057 wxPoint2D *arg2 = 0 ;
7058 bool result;
7059 wxPoint2D temp2 ;
7060 PyObject * obj0 = 0 ;
7061 PyObject * obj1 = 0 ;
7062 char *kwnames[] = {
7063 (char *) "self",(char *) "pt", NULL
7064 };
7065
7066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7068 if (SWIG_arg_fail(1)) SWIG_fail;
7069 {
7070 arg2 = &temp2;
7071 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7072 }
7073 {
7074 PyThreadState* __tstate = wxPyBeginAllowThreads();
7075 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7076
7077 wxPyEndAllowThreads(__tstate);
7078 if (PyErr_Occurred()) SWIG_fail;
7079 }
7080 {
7081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7082 }
7083 return resultobj;
7084 fail:
7085 return NULL;
7086 }
7087
7088
7089 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7090 PyObject *resultobj;
7091 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7092 wxPoint2D *arg2 = 0 ;
7093 bool result;
7094 wxPoint2D temp2 ;
7095 PyObject * obj0 = 0 ;
7096 PyObject * obj1 = 0 ;
7097 char *kwnames[] = {
7098 (char *) "self",(char *) "pt", NULL
7099 };
7100
7101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7103 if (SWIG_arg_fail(1)) SWIG_fail;
7104 {
7105 arg2 = &temp2;
7106 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7107 }
7108 {
7109 PyThreadState* __tstate = wxPyBeginAllowThreads();
7110 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7111
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 {
7116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7117 }
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7125 PyObject *resultobj;
7126 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7127 double arg2 ;
7128 PyObject * obj0 = 0 ;
7129 PyObject * obj1 = 0 ;
7130 char *kwnames[] = {
7131 (char *) "self",(char *) "m_x", NULL
7132 };
7133
7134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7136 if (SWIG_arg_fail(1)) SWIG_fail;
7137 {
7138 arg2 = (double)(SWIG_As_double(obj1));
7139 if (SWIG_arg_fail(2)) SWIG_fail;
7140 }
7141 if (arg1) (arg1)->m_x = arg2;
7142
7143 Py_INCREF(Py_None); resultobj = Py_None;
7144 return resultobj;
7145 fail:
7146 return NULL;
7147 }
7148
7149
7150 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7151 PyObject *resultobj;
7152 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7153 double result;
7154 PyObject * obj0 = 0 ;
7155 char *kwnames[] = {
7156 (char *) "self", NULL
7157 };
7158
7159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7161 if (SWIG_arg_fail(1)) SWIG_fail;
7162 result = (double) ((arg1)->m_x);
7163
7164 {
7165 resultobj = SWIG_From_double((double)(result));
7166 }
7167 return resultobj;
7168 fail:
7169 return NULL;
7170 }
7171
7172
7173 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7174 PyObject *resultobj;
7175 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7176 double arg2 ;
7177 PyObject * obj0 = 0 ;
7178 PyObject * obj1 = 0 ;
7179 char *kwnames[] = {
7180 (char *) "self",(char *) "m_y", NULL
7181 };
7182
7183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7185 if (SWIG_arg_fail(1)) SWIG_fail;
7186 {
7187 arg2 = (double)(SWIG_As_double(obj1));
7188 if (SWIG_arg_fail(2)) SWIG_fail;
7189 }
7190 if (arg1) (arg1)->m_y = arg2;
7191
7192 Py_INCREF(Py_None); resultobj = Py_None;
7193 return resultobj;
7194 fail:
7195 return NULL;
7196 }
7197
7198
7199 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7200 PyObject *resultobj;
7201 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7202 double result;
7203 PyObject * obj0 = 0 ;
7204 char *kwnames[] = {
7205 (char *) "self", NULL
7206 };
7207
7208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7210 if (SWIG_arg_fail(1)) SWIG_fail;
7211 result = (double) ((arg1)->m_y);
7212
7213 {
7214 resultobj = SWIG_From_double((double)(result));
7215 }
7216 return resultobj;
7217 fail:
7218 return NULL;
7219 }
7220
7221
7222 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7223 PyObject *resultobj;
7224 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7225 double arg2 = (double) 0 ;
7226 double arg3 = (double) 0 ;
7227 PyObject * obj0 = 0 ;
7228 PyObject * obj1 = 0 ;
7229 PyObject * obj2 = 0 ;
7230 char *kwnames[] = {
7231 (char *) "self",(char *) "x",(char *) "y", NULL
7232 };
7233
7234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7236 if (SWIG_arg_fail(1)) SWIG_fail;
7237 if (obj1) {
7238 {
7239 arg2 = (double)(SWIG_As_double(obj1));
7240 if (SWIG_arg_fail(2)) SWIG_fail;
7241 }
7242 }
7243 if (obj2) {
7244 {
7245 arg3 = (double)(SWIG_As_double(obj2));
7246 if (SWIG_arg_fail(3)) SWIG_fail;
7247 }
7248 }
7249 {
7250 PyThreadState* __tstate = wxPyBeginAllowThreads();
7251 wxPoint2D_Set(arg1,arg2,arg3);
7252
7253 wxPyEndAllowThreads(__tstate);
7254 if (PyErr_Occurred()) SWIG_fail;
7255 }
7256 Py_INCREF(Py_None); resultobj = Py_None;
7257 return resultobj;
7258 fail:
7259 return NULL;
7260 }
7261
7262
7263 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7264 PyObject *resultobj;
7265 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7266 PyObject *result;
7267 PyObject * obj0 = 0 ;
7268 char *kwnames[] = {
7269 (char *) "self", NULL
7270 };
7271
7272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7274 if (SWIG_arg_fail(1)) SWIG_fail;
7275 {
7276 PyThreadState* __tstate = wxPyBeginAllowThreads();
7277 result = (PyObject *)wxPoint2D_Get(arg1);
7278
7279 wxPyEndAllowThreads(__tstate);
7280 if (PyErr_Occurred()) SWIG_fail;
7281 }
7282 resultobj = result;
7283 return resultobj;
7284 fail:
7285 return NULL;
7286 }
7287
7288
7289 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7290 PyObject *obj;
7291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7292 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7293 Py_INCREF(obj);
7294 return Py_BuildValue((char *)"");
7295 }
7296 static int _wrap_DefaultPosition_set(PyObject *) {
7297 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7298 return 1;
7299 }
7300
7301
7302 static PyObject *_wrap_DefaultPosition_get(void) {
7303 PyObject *pyobj;
7304
7305 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7306 return pyobj;
7307 }
7308
7309
7310 static int _wrap_DefaultSize_set(PyObject *) {
7311 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7312 return 1;
7313 }
7314
7315
7316 static PyObject *_wrap_DefaultSize_get(void) {
7317 PyObject *pyobj;
7318
7319 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7320 return pyobj;
7321 }
7322
7323
7324 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7325 PyObject *resultobj;
7326 PyObject *arg1 = (PyObject *) 0 ;
7327 wxPyInputStream *result;
7328 PyObject * obj0 = 0 ;
7329 char *kwnames[] = {
7330 (char *) "p", NULL
7331 };
7332
7333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7334 arg1 = obj0;
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7338
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7343 return resultobj;
7344 fail:
7345 return NULL;
7346 }
7347
7348
7349 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7350 PyObject *resultobj;
7351 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7352 PyObject * obj0 = 0 ;
7353 char *kwnames[] = {
7354 (char *) "self", NULL
7355 };
7356
7357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7359 if (SWIG_arg_fail(1)) SWIG_fail;
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 delete arg1;
7363
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 Py_INCREF(Py_None); resultobj = Py_None;
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj;
7376 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7377 PyObject * obj0 = 0 ;
7378 char *kwnames[] = {
7379 (char *) "self", NULL
7380 };
7381
7382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7384 if (SWIG_arg_fail(1)) SWIG_fail;
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 (arg1)->close();
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 Py_INCREF(Py_None); resultobj = Py_None;
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj;
7401 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7402 PyObject * obj0 = 0 ;
7403 char *kwnames[] = {
7404 (char *) "self", NULL
7405 };
7406
7407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7409 if (SWIG_arg_fail(1)) SWIG_fail;
7410 {
7411 PyThreadState* __tstate = wxPyBeginAllowThreads();
7412 (arg1)->flush();
7413
7414 wxPyEndAllowThreads(__tstate);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 Py_INCREF(Py_None); resultobj = Py_None;
7418 return resultobj;
7419 fail:
7420 return NULL;
7421 }
7422
7423
7424 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7425 PyObject *resultobj;
7426 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7427 bool result;
7428 PyObject * obj0 = 0 ;
7429 char *kwnames[] = {
7430 (char *) "self", NULL
7431 };
7432
7433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7435 if (SWIG_arg_fail(1)) SWIG_fail;
7436 {
7437 PyThreadState* __tstate = wxPyBeginAllowThreads();
7438 result = (bool)(arg1)->eof();
7439
7440 wxPyEndAllowThreads(__tstate);
7441 if (PyErr_Occurred()) SWIG_fail;
7442 }
7443 {
7444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7445 }
7446 return resultobj;
7447 fail:
7448 return NULL;
7449 }
7450
7451
7452 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7453 PyObject *resultobj;
7454 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7455 int arg2 = (int) -1 ;
7456 PyObject *result;
7457 PyObject * obj0 = 0 ;
7458 PyObject * obj1 = 0 ;
7459 char *kwnames[] = {
7460 (char *) "self",(char *) "size", NULL
7461 };
7462
7463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7465 if (SWIG_arg_fail(1)) SWIG_fail;
7466 if (obj1) {
7467 {
7468 arg2 = (int)(SWIG_As_int(obj1));
7469 if (SWIG_arg_fail(2)) SWIG_fail;
7470 }
7471 }
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 result = (PyObject *)(arg1)->read(arg2);
7475
7476 wxPyEndAllowThreads(__tstate);
7477 if (PyErr_Occurred()) SWIG_fail;
7478 }
7479 resultobj = result;
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7487 PyObject *resultobj;
7488 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7489 int arg2 = (int) -1 ;
7490 PyObject *result;
7491 PyObject * obj0 = 0 ;
7492 PyObject * obj1 = 0 ;
7493 char *kwnames[] = {
7494 (char *) "self",(char *) "size", NULL
7495 };
7496
7497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7499 if (SWIG_arg_fail(1)) SWIG_fail;
7500 if (obj1) {
7501 {
7502 arg2 = (int)(SWIG_As_int(obj1));
7503 if (SWIG_arg_fail(2)) SWIG_fail;
7504 }
7505 }
7506 {
7507 PyThreadState* __tstate = wxPyBeginAllowThreads();
7508 result = (PyObject *)(arg1)->readline(arg2);
7509
7510 wxPyEndAllowThreads(__tstate);
7511 if (PyErr_Occurred()) SWIG_fail;
7512 }
7513 resultobj = result;
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7521 PyObject *resultobj;
7522 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7523 int arg2 = (int) -1 ;
7524 PyObject *result;
7525 PyObject * obj0 = 0 ;
7526 PyObject * obj1 = 0 ;
7527 char *kwnames[] = {
7528 (char *) "self",(char *) "sizehint", NULL
7529 };
7530
7531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7533 if (SWIG_arg_fail(1)) SWIG_fail;
7534 if (obj1) {
7535 {
7536 arg2 = (int)(SWIG_As_int(obj1));
7537 if (SWIG_arg_fail(2)) SWIG_fail;
7538 }
7539 }
7540 {
7541 PyThreadState* __tstate = wxPyBeginAllowThreads();
7542 result = (PyObject *)(arg1)->readlines(arg2);
7543
7544 wxPyEndAllowThreads(__tstate);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 resultobj = result;
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj;
7556 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7557 int arg2 ;
7558 int arg3 = (int) 0 ;
7559 PyObject * obj0 = 0 ;
7560 PyObject * obj1 = 0 ;
7561 PyObject * obj2 = 0 ;
7562 char *kwnames[] = {
7563 (char *) "self",(char *) "offset",(char *) "whence", NULL
7564 };
7565
7566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7568 if (SWIG_arg_fail(1)) SWIG_fail;
7569 {
7570 arg2 = (int)(SWIG_As_int(obj1));
7571 if (SWIG_arg_fail(2)) SWIG_fail;
7572 }
7573 if (obj2) {
7574 {
7575 arg3 = (int)(SWIG_As_int(obj2));
7576 if (SWIG_arg_fail(3)) SWIG_fail;
7577 }
7578 }
7579 {
7580 PyThreadState* __tstate = wxPyBeginAllowThreads();
7581 (arg1)->seek(arg2,arg3);
7582
7583 wxPyEndAllowThreads(__tstate);
7584 if (PyErr_Occurred()) SWIG_fail;
7585 }
7586 Py_INCREF(Py_None); resultobj = Py_None;
7587 return resultobj;
7588 fail:
7589 return NULL;
7590 }
7591
7592
7593 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7594 PyObject *resultobj;
7595 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7596 int result;
7597 PyObject * obj0 = 0 ;
7598 char *kwnames[] = {
7599 (char *) "self", NULL
7600 };
7601
7602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7604 if (SWIG_arg_fail(1)) SWIG_fail;
7605 {
7606 PyThreadState* __tstate = wxPyBeginAllowThreads();
7607 result = (int)(arg1)->tell();
7608
7609 wxPyEndAllowThreads(__tstate);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 {
7613 resultobj = SWIG_From_int((int)(result));
7614 }
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj;
7623 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7624 char result;
7625 PyObject * obj0 = 0 ;
7626 char *kwnames[] = {
7627 (char *) "self", NULL
7628 };
7629
7630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7632 if (SWIG_arg_fail(1)) SWIG_fail;
7633 {
7634 PyThreadState* __tstate = wxPyBeginAllowThreads();
7635 result = (char)(arg1)->Peek();
7636
7637 wxPyEndAllowThreads(__tstate);
7638 if (PyErr_Occurred()) SWIG_fail;
7639 }
7640 {
7641 resultobj = SWIG_From_char((char)(result));
7642 }
7643 return resultobj;
7644 fail:
7645 return NULL;
7646 }
7647
7648
7649 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7650 PyObject *resultobj;
7651 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7652 char result;
7653 PyObject * obj0 = 0 ;
7654 char *kwnames[] = {
7655 (char *) "self", NULL
7656 };
7657
7658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7660 if (SWIG_arg_fail(1)) SWIG_fail;
7661 {
7662 PyThreadState* __tstate = wxPyBeginAllowThreads();
7663 result = (char)(arg1)->GetC();
7664
7665 wxPyEndAllowThreads(__tstate);
7666 if (PyErr_Occurred()) SWIG_fail;
7667 }
7668 {
7669 resultobj = SWIG_From_char((char)(result));
7670 }
7671 return resultobj;
7672 fail:
7673 return NULL;
7674 }
7675
7676
7677 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7678 PyObject *resultobj;
7679 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7680 size_t result;
7681 PyObject * obj0 = 0 ;
7682 char *kwnames[] = {
7683 (char *) "self", NULL
7684 };
7685
7686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7688 if (SWIG_arg_fail(1)) SWIG_fail;
7689 {
7690 PyThreadState* __tstate = wxPyBeginAllowThreads();
7691 result = (size_t)(arg1)->LastRead();
7692
7693 wxPyEndAllowThreads(__tstate);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 {
7697 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7698 }
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7706 PyObject *resultobj;
7707 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7708 bool result;
7709 PyObject * obj0 = 0 ;
7710 char *kwnames[] = {
7711 (char *) "self", NULL
7712 };
7713
7714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7716 if (SWIG_arg_fail(1)) SWIG_fail;
7717 {
7718 PyThreadState* __tstate = wxPyBeginAllowThreads();
7719 result = (bool)(arg1)->CanRead();
7720
7721 wxPyEndAllowThreads(__tstate);
7722 if (PyErr_Occurred()) SWIG_fail;
7723 }
7724 {
7725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7726 }
7727 return resultobj;
7728 fail:
7729 return NULL;
7730 }
7731
7732
7733 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7734 PyObject *resultobj;
7735 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7736 bool result;
7737 PyObject * obj0 = 0 ;
7738 char *kwnames[] = {
7739 (char *) "self", NULL
7740 };
7741
7742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7744 if (SWIG_arg_fail(1)) SWIG_fail;
7745 {
7746 PyThreadState* __tstate = wxPyBeginAllowThreads();
7747 result = (bool)(arg1)->Eof();
7748
7749 wxPyEndAllowThreads(__tstate);
7750 if (PyErr_Occurred()) SWIG_fail;
7751 }
7752 {
7753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7754 }
7755 return resultobj;
7756 fail:
7757 return NULL;
7758 }
7759
7760
7761 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7762 PyObject *resultobj;
7763 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7764 char arg2 ;
7765 bool result;
7766 PyObject * obj0 = 0 ;
7767 PyObject * obj1 = 0 ;
7768 char *kwnames[] = {
7769 (char *) "self",(char *) "c", NULL
7770 };
7771
7772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7774 if (SWIG_arg_fail(1)) SWIG_fail;
7775 {
7776 arg2 = (char)(SWIG_As_char(obj1));
7777 if (SWIG_arg_fail(2)) SWIG_fail;
7778 }
7779 {
7780 PyThreadState* __tstate = wxPyBeginAllowThreads();
7781 result = (bool)(arg1)->Ungetch(arg2);
7782
7783 wxPyEndAllowThreads(__tstate);
7784 if (PyErr_Occurred()) SWIG_fail;
7785 }
7786 {
7787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7788 }
7789 return resultobj;
7790 fail:
7791 return NULL;
7792 }
7793
7794
7795 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7796 PyObject *resultobj;
7797 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7798 long arg2 ;
7799 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7800 long result;
7801 PyObject * obj0 = 0 ;
7802 PyObject * obj1 = 0 ;
7803 PyObject * obj2 = 0 ;
7804 char *kwnames[] = {
7805 (char *) "self",(char *) "pos",(char *) "mode", NULL
7806 };
7807
7808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7810 if (SWIG_arg_fail(1)) SWIG_fail;
7811 {
7812 arg2 = (long)(SWIG_As_long(obj1));
7813 if (SWIG_arg_fail(2)) SWIG_fail;
7814 }
7815 if (obj2) {
7816 {
7817 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7818 if (SWIG_arg_fail(3)) SWIG_fail;
7819 }
7820 }
7821 {
7822 PyThreadState* __tstate = wxPyBeginAllowThreads();
7823 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7824
7825 wxPyEndAllowThreads(__tstate);
7826 if (PyErr_Occurred()) SWIG_fail;
7827 }
7828 {
7829 resultobj = SWIG_From_long((long)(result));
7830 }
7831 return resultobj;
7832 fail:
7833 return NULL;
7834 }
7835
7836
7837 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7838 PyObject *resultobj;
7839 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7840 long result;
7841 PyObject * obj0 = 0 ;
7842 char *kwnames[] = {
7843 (char *) "self", NULL
7844 };
7845
7846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7848 if (SWIG_arg_fail(1)) SWIG_fail;
7849 {
7850 PyThreadState* __tstate = wxPyBeginAllowThreads();
7851 result = (long)(arg1)->TellI();
7852
7853 wxPyEndAllowThreads(__tstate);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 {
7857 resultobj = SWIG_From_long((long)(result));
7858 }
7859 return resultobj;
7860 fail:
7861 return NULL;
7862 }
7863
7864
7865 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7866 PyObject *obj;
7867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7868 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7869 Py_INCREF(obj);
7870 return Py_BuildValue((char *)"");
7871 }
7872 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7873 PyObject *resultobj;
7874 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7875 PyObject *arg2 = (PyObject *) 0 ;
7876 PyObject * obj0 = 0 ;
7877 PyObject * obj1 = 0 ;
7878 char *kwnames[] = {
7879 (char *) "self",(char *) "obj", NULL
7880 };
7881
7882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7884 if (SWIG_arg_fail(1)) SWIG_fail;
7885 arg2 = obj1;
7886 {
7887 PyThreadState* __tstate = wxPyBeginAllowThreads();
7888 wxOutputStream_write(arg1,arg2);
7889
7890 wxPyEndAllowThreads(__tstate);
7891 if (PyErr_Occurred()) SWIG_fail;
7892 }
7893 Py_INCREF(Py_None); resultobj = Py_None;
7894 return resultobj;
7895 fail:
7896 return NULL;
7897 }
7898
7899
7900 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7901 PyObject *obj;
7902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7903 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7904 Py_INCREF(obj);
7905 return Py_BuildValue((char *)"");
7906 }
7907 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7908 PyObject *resultobj;
7909 wxInputStream *arg1 = (wxInputStream *) 0 ;
7910 wxString *arg2 = 0 ;
7911 wxString *arg3 = 0 ;
7912 wxString *arg4 = 0 ;
7913 wxDateTime arg5 ;
7914 wxFSFile *result;
7915 wxPyInputStream *temp1 ;
7916 bool created1 ;
7917 bool temp2 = false ;
7918 bool temp3 = false ;
7919 bool temp4 = false ;
7920 PyObject * obj0 = 0 ;
7921 PyObject * obj1 = 0 ;
7922 PyObject * obj2 = 0 ;
7923 PyObject * obj3 = 0 ;
7924 PyObject * obj4 = 0 ;
7925 char *kwnames[] = {
7926 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7927 };
7928
7929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7930 {
7931 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7932 arg1 = temp1->m_wxis;
7933 created1 = false;
7934 } else {
7935 PyErr_Clear(); // clear the failure of the wxPyConvert above
7936 arg1 = wxPyCBInputStream_create(obj0, false);
7937 if (arg1 == NULL) {
7938 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7939 SWIG_fail;
7940 }
7941 created1 = true;
7942 }
7943 }
7944 {
7945 arg2 = wxString_in_helper(obj1);
7946 if (arg2 == NULL) SWIG_fail;
7947 temp2 = true;
7948 }
7949 {
7950 arg3 = wxString_in_helper(obj2);
7951 if (arg3 == NULL) SWIG_fail;
7952 temp3 = true;
7953 }
7954 {
7955 arg4 = wxString_in_helper(obj3);
7956 if (arg4 == NULL) SWIG_fail;
7957 temp4 = true;
7958 }
7959 {
7960 wxDateTime * argp;
7961 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7962 if (SWIG_arg_fail(5)) SWIG_fail;
7963 if (argp == NULL) {
7964 SWIG_null_ref("wxDateTime");
7965 }
7966 if (SWIG_arg_fail(5)) SWIG_fail;
7967 arg5 = *argp;
7968 }
7969 {
7970 PyThreadState* __tstate = wxPyBeginAllowThreads();
7971 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7972
7973 wxPyEndAllowThreads(__tstate);
7974 if (PyErr_Occurred()) SWIG_fail;
7975 }
7976 {
7977 resultobj = wxPyMake_wxObject(result, 1);
7978 }
7979 {
7980 if (created1)
7981 delete arg1;
7982 }
7983 {
7984 if (temp2)
7985 delete arg2;
7986 }
7987 {
7988 if (temp3)
7989 delete arg3;
7990 }
7991 {
7992 if (temp4)
7993 delete arg4;
7994 }
7995 return resultobj;
7996 fail:
7997 {
7998 if (created1)
7999 delete arg1;
8000 }
8001 {
8002 if (temp2)
8003 delete arg2;
8004 }
8005 {
8006 if (temp3)
8007 delete arg3;
8008 }
8009 {
8010 if (temp4)
8011 delete arg4;
8012 }
8013 return NULL;
8014 }
8015
8016
8017 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8018 PyObject *resultobj;
8019 wxFSFile *arg1 = (wxFSFile *) 0 ;
8020 PyObject * obj0 = 0 ;
8021 char *kwnames[] = {
8022 (char *) "self", NULL
8023 };
8024
8025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8027 if (SWIG_arg_fail(1)) SWIG_fail;
8028 {
8029 PyThreadState* __tstate = wxPyBeginAllowThreads();
8030 delete arg1;
8031
8032 wxPyEndAllowThreads(__tstate);
8033 if (PyErr_Occurred()) SWIG_fail;
8034 }
8035 Py_INCREF(Py_None); resultobj = Py_None;
8036 return resultobj;
8037 fail:
8038 return NULL;
8039 }
8040
8041
8042 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8043 PyObject *resultobj;
8044 wxFSFile *arg1 = (wxFSFile *) 0 ;
8045 wxInputStream *result;
8046 PyObject * obj0 = 0 ;
8047 char *kwnames[] = {
8048 (char *) "self", NULL
8049 };
8050
8051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8053 if (SWIG_arg_fail(1)) SWIG_fail;
8054 {
8055 PyThreadState* __tstate = wxPyBeginAllowThreads();
8056 result = (wxInputStream *)(arg1)->GetStream();
8057
8058 wxPyEndAllowThreads(__tstate);
8059 if (PyErr_Occurred()) SWIG_fail;
8060 }
8061 {
8062 wxPyInputStream * _ptr = NULL;
8063
8064 if (result) {
8065 _ptr = new wxPyInputStream(result);
8066 }
8067 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8068 }
8069 return resultobj;
8070 fail:
8071 return NULL;
8072 }
8073
8074
8075 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8076 PyObject *resultobj;
8077 wxFSFile *arg1 = (wxFSFile *) 0 ;
8078 wxString *result;
8079 PyObject * obj0 = 0 ;
8080 char *kwnames[] = {
8081 (char *) "self", NULL
8082 };
8083
8084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8086 if (SWIG_arg_fail(1)) SWIG_fail;
8087 {
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 {
8090 wxString const &_result_ref = (arg1)->GetMimeType();
8091 result = (wxString *) &_result_ref;
8092 }
8093
8094 wxPyEndAllowThreads(__tstate);
8095 if (PyErr_Occurred()) SWIG_fail;
8096 }
8097 {
8098 #if wxUSE_UNICODE
8099 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8100 #else
8101 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8102 #endif
8103 }
8104 return resultobj;
8105 fail:
8106 return NULL;
8107 }
8108
8109
8110 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8111 PyObject *resultobj;
8112 wxFSFile *arg1 = (wxFSFile *) 0 ;
8113 wxString *result;
8114 PyObject * obj0 = 0 ;
8115 char *kwnames[] = {
8116 (char *) "self", NULL
8117 };
8118
8119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8121 if (SWIG_arg_fail(1)) SWIG_fail;
8122 {
8123 PyThreadState* __tstate = wxPyBeginAllowThreads();
8124 {
8125 wxString const &_result_ref = (arg1)->GetLocation();
8126 result = (wxString *) &_result_ref;
8127 }
8128
8129 wxPyEndAllowThreads(__tstate);
8130 if (PyErr_Occurred()) SWIG_fail;
8131 }
8132 {
8133 #if wxUSE_UNICODE
8134 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8135 #else
8136 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8137 #endif
8138 }
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj;
8147 wxFSFile *arg1 = (wxFSFile *) 0 ;
8148 wxString *result;
8149 PyObject * obj0 = 0 ;
8150 char *kwnames[] = {
8151 (char *) "self", NULL
8152 };
8153
8154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8156 if (SWIG_arg_fail(1)) SWIG_fail;
8157 {
8158 PyThreadState* __tstate = wxPyBeginAllowThreads();
8159 {
8160 wxString const &_result_ref = (arg1)->GetAnchor();
8161 result = (wxString *) &_result_ref;
8162 }
8163
8164 wxPyEndAllowThreads(__tstate);
8165 if (PyErr_Occurred()) SWIG_fail;
8166 }
8167 {
8168 #if wxUSE_UNICODE
8169 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8170 #else
8171 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8172 #endif
8173 }
8174 return resultobj;
8175 fail:
8176 return NULL;
8177 }
8178
8179
8180 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8181 PyObject *resultobj;
8182 wxFSFile *arg1 = (wxFSFile *) 0 ;
8183 wxDateTime result;
8184 PyObject * obj0 = 0 ;
8185 char *kwnames[] = {
8186 (char *) "self", NULL
8187 };
8188
8189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8191 if (SWIG_arg_fail(1)) SWIG_fail;
8192 {
8193 PyThreadState* __tstate = wxPyBeginAllowThreads();
8194 result = (arg1)->GetModificationTime();
8195
8196 wxPyEndAllowThreads(__tstate);
8197 if (PyErr_Occurred()) SWIG_fail;
8198 }
8199 {
8200 wxDateTime * resultptr;
8201 resultptr = new wxDateTime((wxDateTime &)(result));
8202 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8203 }
8204 return resultobj;
8205 fail:
8206 return NULL;
8207 }
8208
8209
8210 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8211 PyObject *obj;
8212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8213 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8214 Py_INCREF(obj);
8215 return Py_BuildValue((char *)"");
8216 }
8217 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8218 PyObject *obj;
8219 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8220 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8221 Py_INCREF(obj);
8222 return Py_BuildValue((char *)"");
8223 }
8224 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8225 PyObject *resultobj;
8226 wxPyFileSystemHandler *result;
8227 char *kwnames[] = {
8228 NULL
8229 };
8230
8231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8232 {
8233 PyThreadState* __tstate = wxPyBeginAllowThreads();
8234 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8235
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8240 return resultobj;
8241 fail:
8242 return NULL;
8243 }
8244
8245
8246 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8247 PyObject *resultobj;
8248 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8249 PyObject *arg2 = (PyObject *) 0 ;
8250 PyObject *arg3 = (PyObject *) 0 ;
8251 PyObject * obj0 = 0 ;
8252 PyObject * obj1 = 0 ;
8253 PyObject * obj2 = 0 ;
8254 char *kwnames[] = {
8255 (char *) "self",(char *) "self",(char *) "_class", NULL
8256 };
8257
8258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8260 if (SWIG_arg_fail(1)) SWIG_fail;
8261 arg2 = obj1;
8262 arg3 = obj2;
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 (arg1)->_setCallbackInfo(arg2,arg3);
8266
8267 wxPyEndAllowThreads(__tstate);
8268 if (PyErr_Occurred()) SWIG_fail;
8269 }
8270 Py_INCREF(Py_None); resultobj = Py_None;
8271 return resultobj;
8272 fail:
8273 return NULL;
8274 }
8275
8276
8277 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8278 PyObject *resultobj;
8279 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8280 wxString *arg2 = 0 ;
8281 bool result;
8282 bool temp2 = false ;
8283 PyObject * obj0 = 0 ;
8284 PyObject * obj1 = 0 ;
8285 char *kwnames[] = {
8286 (char *) "self",(char *) "location", NULL
8287 };
8288
8289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8291 if (SWIG_arg_fail(1)) SWIG_fail;
8292 {
8293 arg2 = wxString_in_helper(obj1);
8294 if (arg2 == NULL) SWIG_fail;
8295 temp2 = true;
8296 }
8297 {
8298 PyThreadState* __tstate = wxPyBeginAllowThreads();
8299 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8300
8301 wxPyEndAllowThreads(__tstate);
8302 if (PyErr_Occurred()) SWIG_fail;
8303 }
8304 {
8305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8306 }
8307 {
8308 if (temp2)
8309 delete arg2;
8310 }
8311 return resultobj;
8312 fail:
8313 {
8314 if (temp2)
8315 delete arg2;
8316 }
8317 return NULL;
8318 }
8319
8320
8321 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8322 PyObject *resultobj;
8323 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8324 wxFileSystem *arg2 = 0 ;
8325 wxString *arg3 = 0 ;
8326 wxFSFile *result;
8327 bool temp3 = false ;
8328 PyObject * obj0 = 0 ;
8329 PyObject * obj1 = 0 ;
8330 PyObject * obj2 = 0 ;
8331 char *kwnames[] = {
8332 (char *) "self",(char *) "fs",(char *) "location", NULL
8333 };
8334
8335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8337 if (SWIG_arg_fail(1)) SWIG_fail;
8338 {
8339 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8340 if (SWIG_arg_fail(2)) SWIG_fail;
8341 if (arg2 == NULL) {
8342 SWIG_null_ref("wxFileSystem");
8343 }
8344 if (SWIG_arg_fail(2)) SWIG_fail;
8345 }
8346 {
8347 arg3 = wxString_in_helper(obj2);
8348 if (arg3 == NULL) SWIG_fail;
8349 temp3 = true;
8350 }
8351 {
8352 PyThreadState* __tstate = wxPyBeginAllowThreads();
8353 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8354
8355 wxPyEndAllowThreads(__tstate);
8356 if (PyErr_Occurred()) SWIG_fail;
8357 }
8358 {
8359 resultobj = wxPyMake_wxObject(result, 1);
8360 }
8361 {
8362 if (temp3)
8363 delete arg3;
8364 }
8365 return resultobj;
8366 fail:
8367 {
8368 if (temp3)
8369 delete arg3;
8370 }
8371 return NULL;
8372 }
8373
8374
8375 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8376 PyObject *resultobj;
8377 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8378 wxString *arg2 = 0 ;
8379 int arg3 = (int) 0 ;
8380 wxString result;
8381 bool temp2 = false ;
8382 PyObject * obj0 = 0 ;
8383 PyObject * obj1 = 0 ;
8384 PyObject * obj2 = 0 ;
8385 char *kwnames[] = {
8386 (char *) "self",(char *) "spec",(char *) "flags", NULL
8387 };
8388
8389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8391 if (SWIG_arg_fail(1)) SWIG_fail;
8392 {
8393 arg2 = wxString_in_helper(obj1);
8394 if (arg2 == NULL) SWIG_fail;
8395 temp2 = true;
8396 }
8397 if (obj2) {
8398 {
8399 arg3 = (int)(SWIG_As_int(obj2));
8400 if (SWIG_arg_fail(3)) SWIG_fail;
8401 }
8402 }
8403 {
8404 PyThreadState* __tstate = wxPyBeginAllowThreads();
8405 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8406
8407 wxPyEndAllowThreads(__tstate);
8408 if (PyErr_Occurred()) SWIG_fail;
8409 }
8410 {
8411 #if wxUSE_UNICODE
8412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8413 #else
8414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8415 #endif
8416 }
8417 {
8418 if (temp2)
8419 delete arg2;
8420 }
8421 return resultobj;
8422 fail:
8423 {
8424 if (temp2)
8425 delete arg2;
8426 }
8427 return NULL;
8428 }
8429
8430
8431 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8432 PyObject *resultobj;
8433 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8434 wxString result;
8435 PyObject * obj0 = 0 ;
8436 char *kwnames[] = {
8437 (char *) "self", NULL
8438 };
8439
8440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8442 if (SWIG_arg_fail(1)) SWIG_fail;
8443 {
8444 PyThreadState* __tstate = wxPyBeginAllowThreads();
8445 result = (arg1)->FindNext();
8446
8447 wxPyEndAllowThreads(__tstate);
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 {
8451 #if wxUSE_UNICODE
8452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8453 #else
8454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8455 #endif
8456 }
8457 return resultobj;
8458 fail:
8459 return NULL;
8460 }
8461
8462
8463 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8464 PyObject *resultobj;
8465 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8466 wxString *arg2 = 0 ;
8467 wxString result;
8468 bool temp2 = false ;
8469 PyObject * obj0 = 0 ;
8470 PyObject * obj1 = 0 ;
8471 char *kwnames[] = {
8472 (char *) "self",(char *) "location", NULL
8473 };
8474
8475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8477 if (SWIG_arg_fail(1)) SWIG_fail;
8478 {
8479 arg2 = wxString_in_helper(obj1);
8480 if (arg2 == NULL) SWIG_fail;
8481 temp2 = true;
8482 }
8483 {
8484 PyThreadState* __tstate = wxPyBeginAllowThreads();
8485 result = (arg1)->GetProtocol((wxString const &)*arg2);
8486
8487 wxPyEndAllowThreads(__tstate);
8488 if (PyErr_Occurred()) SWIG_fail;
8489 }
8490 {
8491 #if wxUSE_UNICODE
8492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8493 #else
8494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8495 #endif
8496 }
8497 {
8498 if (temp2)
8499 delete arg2;
8500 }
8501 return resultobj;
8502 fail:
8503 {
8504 if (temp2)
8505 delete arg2;
8506 }
8507 return NULL;
8508 }
8509
8510
8511 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8512 PyObject *resultobj;
8513 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8514 wxString *arg2 = 0 ;
8515 wxString result;
8516 bool temp2 = false ;
8517 PyObject * obj0 = 0 ;
8518 PyObject * obj1 = 0 ;
8519 char *kwnames[] = {
8520 (char *) "self",(char *) "location", NULL
8521 };
8522
8523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8525 if (SWIG_arg_fail(1)) SWIG_fail;
8526 {
8527 arg2 = wxString_in_helper(obj1);
8528 if (arg2 == NULL) SWIG_fail;
8529 temp2 = true;
8530 }
8531 {
8532 PyThreadState* __tstate = wxPyBeginAllowThreads();
8533 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8534
8535 wxPyEndAllowThreads(__tstate);
8536 if (PyErr_Occurred()) SWIG_fail;
8537 }
8538 {
8539 #if wxUSE_UNICODE
8540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8541 #else
8542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8543 #endif
8544 }
8545 {
8546 if (temp2)
8547 delete arg2;
8548 }
8549 return resultobj;
8550 fail:
8551 {
8552 if (temp2)
8553 delete arg2;
8554 }
8555 return NULL;
8556 }
8557
8558
8559 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8560 PyObject *resultobj;
8561 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8562 wxString *arg2 = 0 ;
8563 wxString result;
8564 bool temp2 = false ;
8565 PyObject * obj0 = 0 ;
8566 PyObject * obj1 = 0 ;
8567 char *kwnames[] = {
8568 (char *) "self",(char *) "location", NULL
8569 };
8570
8571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8573 if (SWIG_arg_fail(1)) SWIG_fail;
8574 {
8575 arg2 = wxString_in_helper(obj1);
8576 if (arg2 == NULL) SWIG_fail;
8577 temp2 = true;
8578 }
8579 {
8580 PyThreadState* __tstate = wxPyBeginAllowThreads();
8581 result = (arg1)->GetAnchor((wxString const &)*arg2);
8582
8583 wxPyEndAllowThreads(__tstate);
8584 if (PyErr_Occurred()) SWIG_fail;
8585 }
8586 {
8587 #if wxUSE_UNICODE
8588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8589 #else
8590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8591 #endif
8592 }
8593 {
8594 if (temp2)
8595 delete arg2;
8596 }
8597 return resultobj;
8598 fail:
8599 {
8600 if (temp2)
8601 delete arg2;
8602 }
8603 return NULL;
8604 }
8605
8606
8607 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8608 PyObject *resultobj;
8609 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8610 wxString *arg2 = 0 ;
8611 wxString result;
8612 bool temp2 = false ;
8613 PyObject * obj0 = 0 ;
8614 PyObject * obj1 = 0 ;
8615 char *kwnames[] = {
8616 (char *) "self",(char *) "location", NULL
8617 };
8618
8619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8621 if (SWIG_arg_fail(1)) SWIG_fail;
8622 {
8623 arg2 = wxString_in_helper(obj1);
8624 if (arg2 == NULL) SWIG_fail;
8625 temp2 = true;
8626 }
8627 {
8628 PyThreadState* __tstate = wxPyBeginAllowThreads();
8629 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8630
8631 wxPyEndAllowThreads(__tstate);
8632 if (PyErr_Occurred()) SWIG_fail;
8633 }
8634 {
8635 #if wxUSE_UNICODE
8636 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8637 #else
8638 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8639 #endif
8640 }
8641 {
8642 if (temp2)
8643 delete arg2;
8644 }
8645 return resultobj;
8646 fail:
8647 {
8648 if (temp2)
8649 delete arg2;
8650 }
8651 return NULL;
8652 }
8653
8654
8655 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8656 PyObject *resultobj;
8657 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8658 wxString *arg2 = 0 ;
8659 wxString result;
8660 bool temp2 = false ;
8661 PyObject * obj0 = 0 ;
8662 PyObject * obj1 = 0 ;
8663 char *kwnames[] = {
8664 (char *) "self",(char *) "location", NULL
8665 };
8666
8667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8669 if (SWIG_arg_fail(1)) SWIG_fail;
8670 {
8671 arg2 = wxString_in_helper(obj1);
8672 if (arg2 == NULL) SWIG_fail;
8673 temp2 = true;
8674 }
8675 {
8676 PyThreadState* __tstate = wxPyBeginAllowThreads();
8677 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8678
8679 wxPyEndAllowThreads(__tstate);
8680 if (PyErr_Occurred()) SWIG_fail;
8681 }
8682 {
8683 #if wxUSE_UNICODE
8684 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8685 #else
8686 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8687 #endif
8688 }
8689 {
8690 if (temp2)
8691 delete arg2;
8692 }
8693 return resultobj;
8694 fail:
8695 {
8696 if (temp2)
8697 delete arg2;
8698 }
8699 return NULL;
8700 }
8701
8702
8703 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8704 PyObject *obj;
8705 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8706 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8707 Py_INCREF(obj);
8708 return Py_BuildValue((char *)"");
8709 }
8710 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8711 PyObject *resultobj;
8712 wxFileSystem *result;
8713 char *kwnames[] = {
8714 NULL
8715 };
8716
8717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8718 {
8719 PyThreadState* __tstate = wxPyBeginAllowThreads();
8720 result = (wxFileSystem *)new wxFileSystem();
8721
8722 wxPyEndAllowThreads(__tstate);
8723 if (PyErr_Occurred()) SWIG_fail;
8724 }
8725 {
8726 resultobj = wxPyMake_wxObject(result, 1);
8727 }
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj;
8736 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8737 PyObject * obj0 = 0 ;
8738 char *kwnames[] = {
8739 (char *) "self", NULL
8740 };
8741
8742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8744 if (SWIG_arg_fail(1)) SWIG_fail;
8745 {
8746 PyThreadState* __tstate = wxPyBeginAllowThreads();
8747 delete arg1;
8748
8749 wxPyEndAllowThreads(__tstate);
8750 if (PyErr_Occurred()) SWIG_fail;
8751 }
8752 Py_INCREF(Py_None); resultobj = Py_None;
8753 return resultobj;
8754 fail:
8755 return NULL;
8756 }
8757
8758
8759 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8760 PyObject *resultobj;
8761 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8762 wxString *arg2 = 0 ;
8763 bool arg3 = (bool) false ;
8764 bool temp2 = false ;
8765 PyObject * obj0 = 0 ;
8766 PyObject * obj1 = 0 ;
8767 PyObject * obj2 = 0 ;
8768 char *kwnames[] = {
8769 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8770 };
8771
8772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8774 if (SWIG_arg_fail(1)) SWIG_fail;
8775 {
8776 arg2 = wxString_in_helper(obj1);
8777 if (arg2 == NULL) SWIG_fail;
8778 temp2 = true;
8779 }
8780 if (obj2) {
8781 {
8782 arg3 = (bool)(SWIG_As_bool(obj2));
8783 if (SWIG_arg_fail(3)) SWIG_fail;
8784 }
8785 }
8786 {
8787 PyThreadState* __tstate = wxPyBeginAllowThreads();
8788 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8789
8790 wxPyEndAllowThreads(__tstate);
8791 if (PyErr_Occurred()) SWIG_fail;
8792 }
8793 Py_INCREF(Py_None); resultobj = Py_None;
8794 {
8795 if (temp2)
8796 delete arg2;
8797 }
8798 return resultobj;
8799 fail:
8800 {
8801 if (temp2)
8802 delete arg2;
8803 }
8804 return NULL;
8805 }
8806
8807
8808 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8809 PyObject *resultobj;
8810 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8811 wxString result;
8812 PyObject * obj0 = 0 ;
8813 char *kwnames[] = {
8814 (char *) "self", NULL
8815 };
8816
8817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8819 if (SWIG_arg_fail(1)) SWIG_fail;
8820 {
8821 PyThreadState* __tstate = wxPyBeginAllowThreads();
8822 result = (arg1)->GetPath();
8823
8824 wxPyEndAllowThreads(__tstate);
8825 if (PyErr_Occurred()) SWIG_fail;
8826 }
8827 {
8828 #if wxUSE_UNICODE
8829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8830 #else
8831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8832 #endif
8833 }
8834 return resultobj;
8835 fail:
8836 return NULL;
8837 }
8838
8839
8840 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8841 PyObject *resultobj;
8842 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8843 wxString *arg2 = 0 ;
8844 wxFSFile *result;
8845 bool temp2 = false ;
8846 PyObject * obj0 = 0 ;
8847 PyObject * obj1 = 0 ;
8848 char *kwnames[] = {
8849 (char *) "self",(char *) "location", NULL
8850 };
8851
8852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8854 if (SWIG_arg_fail(1)) SWIG_fail;
8855 {
8856 arg2 = wxString_in_helper(obj1);
8857 if (arg2 == NULL) SWIG_fail;
8858 temp2 = true;
8859 }
8860 {
8861 PyThreadState* __tstate = wxPyBeginAllowThreads();
8862 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8863
8864 wxPyEndAllowThreads(__tstate);
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 {
8868 resultobj = wxPyMake_wxObject(result, 1);
8869 }
8870 {
8871 if (temp2)
8872 delete arg2;
8873 }
8874 return resultobj;
8875 fail:
8876 {
8877 if (temp2)
8878 delete arg2;
8879 }
8880 return NULL;
8881 }
8882
8883
8884 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj;
8886 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8887 wxString *arg2 = 0 ;
8888 int arg3 = (int) 0 ;
8889 wxString result;
8890 bool temp2 = false ;
8891 PyObject * obj0 = 0 ;
8892 PyObject * obj1 = 0 ;
8893 PyObject * obj2 = 0 ;
8894 char *kwnames[] = {
8895 (char *) "self",(char *) "spec",(char *) "flags", NULL
8896 };
8897
8898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8900 if (SWIG_arg_fail(1)) SWIG_fail;
8901 {
8902 arg2 = wxString_in_helper(obj1);
8903 if (arg2 == NULL) SWIG_fail;
8904 temp2 = true;
8905 }
8906 if (obj2) {
8907 {
8908 arg3 = (int)(SWIG_As_int(obj2));
8909 if (SWIG_arg_fail(3)) SWIG_fail;
8910 }
8911 }
8912 {
8913 PyThreadState* __tstate = wxPyBeginAllowThreads();
8914 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8915
8916 wxPyEndAllowThreads(__tstate);
8917 if (PyErr_Occurred()) SWIG_fail;
8918 }
8919 {
8920 #if wxUSE_UNICODE
8921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8922 #else
8923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8924 #endif
8925 }
8926 {
8927 if (temp2)
8928 delete arg2;
8929 }
8930 return resultobj;
8931 fail:
8932 {
8933 if (temp2)
8934 delete arg2;
8935 }
8936 return NULL;
8937 }
8938
8939
8940 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8941 PyObject *resultobj;
8942 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8943 wxString result;
8944 PyObject * obj0 = 0 ;
8945 char *kwnames[] = {
8946 (char *) "self", NULL
8947 };
8948
8949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8951 if (SWIG_arg_fail(1)) SWIG_fail;
8952 {
8953 PyThreadState* __tstate = wxPyBeginAllowThreads();
8954 result = (arg1)->FindNext();
8955
8956 wxPyEndAllowThreads(__tstate);
8957 if (PyErr_Occurred()) SWIG_fail;
8958 }
8959 {
8960 #if wxUSE_UNICODE
8961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8962 #else
8963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8964 #endif
8965 }
8966 return resultobj;
8967 fail:
8968 return NULL;
8969 }
8970
8971
8972 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8973 PyObject *resultobj;
8974 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8975 PyObject * obj0 = 0 ;
8976 char *kwnames[] = {
8977 (char *) "handler", NULL
8978 };
8979
8980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8982 if (SWIG_arg_fail(1)) SWIG_fail;
8983 {
8984 PyThreadState* __tstate = wxPyBeginAllowThreads();
8985 wxFileSystem::AddHandler(arg1);
8986
8987 wxPyEndAllowThreads(__tstate);
8988 if (PyErr_Occurred()) SWIG_fail;
8989 }
8990 Py_INCREF(Py_None); resultobj = Py_None;
8991 return resultobj;
8992 fail:
8993 return NULL;
8994 }
8995
8996
8997 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8998 PyObject *resultobj;
8999 char *kwnames[] = {
9000 NULL
9001 };
9002
9003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9004 {
9005 PyThreadState* __tstate = wxPyBeginAllowThreads();
9006 wxFileSystem::CleanUpHandlers();
9007
9008 wxPyEndAllowThreads(__tstate);
9009 if (PyErr_Occurred()) SWIG_fail;
9010 }
9011 Py_INCREF(Py_None); resultobj = Py_None;
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9019 PyObject *resultobj;
9020 wxString *arg1 = 0 ;
9021 wxString result;
9022 bool temp1 = false ;
9023 PyObject * obj0 = 0 ;
9024 char *kwnames[] = {
9025 (char *) "filename", NULL
9026 };
9027
9028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9029 {
9030 arg1 = wxString_in_helper(obj0);
9031 if (arg1 == NULL) SWIG_fail;
9032 temp1 = true;
9033 }
9034 {
9035 PyThreadState* __tstate = wxPyBeginAllowThreads();
9036 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9037
9038 wxPyEndAllowThreads(__tstate);
9039 if (PyErr_Occurred()) SWIG_fail;
9040 }
9041 {
9042 #if wxUSE_UNICODE
9043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9044 #else
9045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9046 #endif
9047 }
9048 {
9049 if (temp1)
9050 delete arg1;
9051 }
9052 return resultobj;
9053 fail:
9054 {
9055 if (temp1)
9056 delete arg1;
9057 }
9058 return NULL;
9059 }
9060
9061
9062 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9063 PyObject *resultobj;
9064 wxString *arg1 = 0 ;
9065 wxString result;
9066 bool temp1 = false ;
9067 PyObject * obj0 = 0 ;
9068 char *kwnames[] = {
9069 (char *) "url", NULL
9070 };
9071
9072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9073 {
9074 arg1 = wxString_in_helper(obj0);
9075 if (arg1 == NULL) SWIG_fail;
9076 temp1 = true;
9077 }
9078 {
9079 PyThreadState* __tstate = wxPyBeginAllowThreads();
9080 result = FileSystem_URLToFileName((wxString const &)*arg1);
9081
9082 wxPyEndAllowThreads(__tstate);
9083 if (PyErr_Occurred()) SWIG_fail;
9084 }
9085 {
9086 #if wxUSE_UNICODE
9087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9088 #else
9089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9090 #endif
9091 }
9092 {
9093 if (temp1)
9094 delete arg1;
9095 }
9096 return resultobj;
9097 fail:
9098 {
9099 if (temp1)
9100 delete arg1;
9101 }
9102 return NULL;
9103 }
9104
9105
9106 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9107 PyObject *obj;
9108 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9109 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9110 Py_INCREF(obj);
9111 return Py_BuildValue((char *)"");
9112 }
9113 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9114 PyObject *resultobj;
9115 wxInternetFSHandler *result;
9116 char *kwnames[] = {
9117 NULL
9118 };
9119
9120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9121 {
9122 PyThreadState* __tstate = wxPyBeginAllowThreads();
9123 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9124
9125 wxPyEndAllowThreads(__tstate);
9126 if (PyErr_Occurred()) SWIG_fail;
9127 }
9128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9136 PyObject *resultobj;
9137 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9138 wxString *arg2 = 0 ;
9139 bool result;
9140 bool temp2 = false ;
9141 PyObject * obj0 = 0 ;
9142 PyObject * obj1 = 0 ;
9143 char *kwnames[] = {
9144 (char *) "self",(char *) "location", NULL
9145 };
9146
9147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9149 if (SWIG_arg_fail(1)) SWIG_fail;
9150 {
9151 arg2 = wxString_in_helper(obj1);
9152 if (arg2 == NULL) SWIG_fail;
9153 temp2 = true;
9154 }
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9158
9159 wxPyEndAllowThreads(__tstate);
9160 if (PyErr_Occurred()) SWIG_fail;
9161 }
9162 {
9163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9164 }
9165 {
9166 if (temp2)
9167 delete arg2;
9168 }
9169 return resultobj;
9170 fail:
9171 {
9172 if (temp2)
9173 delete arg2;
9174 }
9175 return NULL;
9176 }
9177
9178
9179 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9180 PyObject *resultobj;
9181 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9182 wxFileSystem *arg2 = 0 ;
9183 wxString *arg3 = 0 ;
9184 wxFSFile *result;
9185 bool temp3 = false ;
9186 PyObject * obj0 = 0 ;
9187 PyObject * obj1 = 0 ;
9188 PyObject * obj2 = 0 ;
9189 char *kwnames[] = {
9190 (char *) "self",(char *) "fs",(char *) "location", NULL
9191 };
9192
9193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9195 if (SWIG_arg_fail(1)) SWIG_fail;
9196 {
9197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9198 if (SWIG_arg_fail(2)) SWIG_fail;
9199 if (arg2 == NULL) {
9200 SWIG_null_ref("wxFileSystem");
9201 }
9202 if (SWIG_arg_fail(2)) SWIG_fail;
9203 }
9204 {
9205 arg3 = wxString_in_helper(obj2);
9206 if (arg3 == NULL) SWIG_fail;
9207 temp3 = true;
9208 }
9209 {
9210 PyThreadState* __tstate = wxPyBeginAllowThreads();
9211 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9212
9213 wxPyEndAllowThreads(__tstate);
9214 if (PyErr_Occurred()) SWIG_fail;
9215 }
9216 {
9217 resultobj = wxPyMake_wxObject(result, 1);
9218 }
9219 {
9220 if (temp3)
9221 delete arg3;
9222 }
9223 return resultobj;
9224 fail:
9225 {
9226 if (temp3)
9227 delete arg3;
9228 }
9229 return NULL;
9230 }
9231
9232
9233 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9234 PyObject *obj;
9235 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9236 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9237 Py_INCREF(obj);
9238 return Py_BuildValue((char *)"");
9239 }
9240 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9241 PyObject *resultobj;
9242 wxZipFSHandler *result;
9243 char *kwnames[] = {
9244 NULL
9245 };
9246
9247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9248 {
9249 PyThreadState* __tstate = wxPyBeginAllowThreads();
9250 result = (wxZipFSHandler *)new wxZipFSHandler();
9251
9252 wxPyEndAllowThreads(__tstate);
9253 if (PyErr_Occurred()) SWIG_fail;
9254 }
9255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9256 return resultobj;
9257 fail:
9258 return NULL;
9259 }
9260
9261
9262 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9263 PyObject *resultobj;
9264 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9265 wxString *arg2 = 0 ;
9266 bool result;
9267 bool temp2 = false ;
9268 PyObject * obj0 = 0 ;
9269 PyObject * obj1 = 0 ;
9270 char *kwnames[] = {
9271 (char *) "self",(char *) "location", NULL
9272 };
9273
9274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9276 if (SWIG_arg_fail(1)) SWIG_fail;
9277 {
9278 arg2 = wxString_in_helper(obj1);
9279 if (arg2 == NULL) SWIG_fail;
9280 temp2 = true;
9281 }
9282 {
9283 PyThreadState* __tstate = wxPyBeginAllowThreads();
9284 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9285
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 {
9290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9291 }
9292 {
9293 if (temp2)
9294 delete arg2;
9295 }
9296 return resultobj;
9297 fail:
9298 {
9299 if (temp2)
9300 delete arg2;
9301 }
9302 return NULL;
9303 }
9304
9305
9306 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9307 PyObject *resultobj;
9308 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9309 wxFileSystem *arg2 = 0 ;
9310 wxString *arg3 = 0 ;
9311 wxFSFile *result;
9312 bool temp3 = false ;
9313 PyObject * obj0 = 0 ;
9314 PyObject * obj1 = 0 ;
9315 PyObject * obj2 = 0 ;
9316 char *kwnames[] = {
9317 (char *) "self",(char *) "fs",(char *) "location", NULL
9318 };
9319
9320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9322 if (SWIG_arg_fail(1)) SWIG_fail;
9323 {
9324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9325 if (SWIG_arg_fail(2)) SWIG_fail;
9326 if (arg2 == NULL) {
9327 SWIG_null_ref("wxFileSystem");
9328 }
9329 if (SWIG_arg_fail(2)) SWIG_fail;
9330 }
9331 {
9332 arg3 = wxString_in_helper(obj2);
9333 if (arg3 == NULL) SWIG_fail;
9334 temp3 = true;
9335 }
9336 {
9337 PyThreadState* __tstate = wxPyBeginAllowThreads();
9338 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9339
9340 wxPyEndAllowThreads(__tstate);
9341 if (PyErr_Occurred()) SWIG_fail;
9342 }
9343 {
9344 resultobj = wxPyMake_wxObject(result, 1);
9345 }
9346 {
9347 if (temp3)
9348 delete arg3;
9349 }
9350 return resultobj;
9351 fail:
9352 {
9353 if (temp3)
9354 delete arg3;
9355 }
9356 return NULL;
9357 }
9358
9359
9360 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9361 PyObject *resultobj;
9362 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9363 wxString *arg2 = 0 ;
9364 int arg3 = (int) 0 ;
9365 wxString result;
9366 bool temp2 = false ;
9367 PyObject * obj0 = 0 ;
9368 PyObject * obj1 = 0 ;
9369 PyObject * obj2 = 0 ;
9370 char *kwnames[] = {
9371 (char *) "self",(char *) "spec",(char *) "flags", NULL
9372 };
9373
9374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9376 if (SWIG_arg_fail(1)) SWIG_fail;
9377 {
9378 arg2 = wxString_in_helper(obj1);
9379 if (arg2 == NULL) SWIG_fail;
9380 temp2 = true;
9381 }
9382 if (obj2) {
9383 {
9384 arg3 = (int)(SWIG_As_int(obj2));
9385 if (SWIG_arg_fail(3)) SWIG_fail;
9386 }
9387 }
9388 {
9389 PyThreadState* __tstate = wxPyBeginAllowThreads();
9390 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9391
9392 wxPyEndAllowThreads(__tstate);
9393 if (PyErr_Occurred()) SWIG_fail;
9394 }
9395 {
9396 #if wxUSE_UNICODE
9397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9398 #else
9399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9400 #endif
9401 }
9402 {
9403 if (temp2)
9404 delete arg2;
9405 }
9406 return resultobj;
9407 fail:
9408 {
9409 if (temp2)
9410 delete arg2;
9411 }
9412 return NULL;
9413 }
9414
9415
9416 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9417 PyObject *resultobj;
9418 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9419 wxString result;
9420 PyObject * obj0 = 0 ;
9421 char *kwnames[] = {
9422 (char *) "self", NULL
9423 };
9424
9425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9427 if (SWIG_arg_fail(1)) SWIG_fail;
9428 {
9429 PyThreadState* __tstate = wxPyBeginAllowThreads();
9430 result = (arg1)->FindNext();
9431
9432 wxPyEndAllowThreads(__tstate);
9433 if (PyErr_Occurred()) SWIG_fail;
9434 }
9435 {
9436 #if wxUSE_UNICODE
9437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9438 #else
9439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9440 #endif
9441 }
9442 return resultobj;
9443 fail:
9444 return NULL;
9445 }
9446
9447
9448 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9449 PyObject *obj;
9450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9451 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9452 Py_INCREF(obj);
9453 return Py_BuildValue((char *)"");
9454 }
9455 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9456 PyObject *resultobj;
9457 wxString *arg1 = 0 ;
9458 wxImage *arg2 = 0 ;
9459 long arg3 ;
9460 bool temp1 = false ;
9461 PyObject * obj0 = 0 ;
9462 PyObject * obj1 = 0 ;
9463 PyObject * obj2 = 0 ;
9464 char *kwnames[] = {
9465 (char *) "filename",(char *) "image",(char *) "type", NULL
9466 };
9467
9468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9469 {
9470 arg1 = wxString_in_helper(obj0);
9471 if (arg1 == NULL) SWIG_fail;
9472 temp1 = true;
9473 }
9474 {
9475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9476 if (SWIG_arg_fail(2)) SWIG_fail;
9477 if (arg2 == NULL) {
9478 SWIG_null_ref("wxImage");
9479 }
9480 if (SWIG_arg_fail(2)) SWIG_fail;
9481 }
9482 {
9483 arg3 = (long)(SWIG_As_long(obj2));
9484 if (SWIG_arg_fail(3)) SWIG_fail;
9485 }
9486 {
9487 PyThreadState* __tstate = wxPyBeginAllowThreads();
9488 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9489
9490 wxPyEndAllowThreads(__tstate);
9491 if (PyErr_Occurred()) SWIG_fail;
9492 }
9493 Py_INCREF(Py_None); resultobj = Py_None;
9494 {
9495 if (temp1)
9496 delete arg1;
9497 }
9498 return resultobj;
9499 fail:
9500 {
9501 if (temp1)
9502 delete arg1;
9503 }
9504 return NULL;
9505 }
9506
9507
9508 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9509 PyObject *resultobj;
9510 wxString *arg1 = 0 ;
9511 wxBitmap *arg2 = 0 ;
9512 long arg3 ;
9513 bool temp1 = false ;
9514 PyObject * obj0 = 0 ;
9515 PyObject * obj1 = 0 ;
9516 PyObject * obj2 = 0 ;
9517 char *kwnames[] = {
9518 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9519 };
9520
9521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9522 {
9523 arg1 = wxString_in_helper(obj0);
9524 if (arg1 == NULL) SWIG_fail;
9525 temp1 = true;
9526 }
9527 {
9528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9529 if (SWIG_arg_fail(2)) SWIG_fail;
9530 if (arg2 == NULL) {
9531 SWIG_null_ref("wxBitmap");
9532 }
9533 if (SWIG_arg_fail(2)) SWIG_fail;
9534 }
9535 {
9536 arg3 = (long)(SWIG_As_long(obj2));
9537 if (SWIG_arg_fail(3)) SWIG_fail;
9538 }
9539 {
9540 PyThreadState* __tstate = wxPyBeginAllowThreads();
9541 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9542
9543 wxPyEndAllowThreads(__tstate);
9544 if (PyErr_Occurred()) SWIG_fail;
9545 }
9546 Py_INCREF(Py_None); resultobj = Py_None;
9547 {
9548 if (temp1)
9549 delete arg1;
9550 }
9551 return resultobj;
9552 fail:
9553 {
9554 if (temp1)
9555 delete arg1;
9556 }
9557 return NULL;
9558 }
9559
9560
9561 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9562 PyObject *resultobj;
9563 wxString *arg1 = 0 ;
9564 PyObject *arg2 = (PyObject *) 0 ;
9565 bool temp1 = false ;
9566 PyObject * obj0 = 0 ;
9567 PyObject * obj1 = 0 ;
9568 char *kwnames[] = {
9569 (char *) "filename",(char *) "data", NULL
9570 };
9571
9572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9573 {
9574 arg1 = wxString_in_helper(obj0);
9575 if (arg1 == NULL) SWIG_fail;
9576 temp1 = true;
9577 }
9578 arg2 = obj1;
9579 {
9580 PyThreadState* __tstate = wxPyBeginAllowThreads();
9581 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9582
9583 wxPyEndAllowThreads(__tstate);
9584 if (PyErr_Occurred()) SWIG_fail;
9585 }
9586 Py_INCREF(Py_None); resultobj = Py_None;
9587 {
9588 if (temp1)
9589 delete arg1;
9590 }
9591 return resultobj;
9592 fail:
9593 {
9594 if (temp1)
9595 delete arg1;
9596 }
9597 return NULL;
9598 }
9599
9600
9601 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9602 PyObject *resultobj;
9603 wxMemoryFSHandler *result;
9604 char *kwnames[] = {
9605 NULL
9606 };
9607
9608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9609 {
9610 PyThreadState* __tstate = wxPyBeginAllowThreads();
9611 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9612
9613 wxPyEndAllowThreads(__tstate);
9614 if (PyErr_Occurred()) SWIG_fail;
9615 }
9616 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9617 return resultobj;
9618 fail:
9619 return NULL;
9620 }
9621
9622
9623 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9624 PyObject *resultobj;
9625 wxString *arg1 = 0 ;
9626 bool temp1 = false ;
9627 PyObject * obj0 = 0 ;
9628 char *kwnames[] = {
9629 (char *) "filename", NULL
9630 };
9631
9632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9633 {
9634 arg1 = wxString_in_helper(obj0);
9635 if (arg1 == NULL) SWIG_fail;
9636 temp1 = true;
9637 }
9638 {
9639 PyThreadState* __tstate = wxPyBeginAllowThreads();
9640 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9641
9642 wxPyEndAllowThreads(__tstate);
9643 if (PyErr_Occurred()) SWIG_fail;
9644 }
9645 Py_INCREF(Py_None); resultobj = Py_None;
9646 {
9647 if (temp1)
9648 delete arg1;
9649 }
9650 return resultobj;
9651 fail:
9652 {
9653 if (temp1)
9654 delete arg1;
9655 }
9656 return NULL;
9657 }
9658
9659
9660 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9661 PyObject *resultobj;
9662 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9663 wxString *arg2 = 0 ;
9664 bool result;
9665 bool temp2 = false ;
9666 PyObject * obj0 = 0 ;
9667 PyObject * obj1 = 0 ;
9668 char *kwnames[] = {
9669 (char *) "self",(char *) "location", NULL
9670 };
9671
9672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9674 if (SWIG_arg_fail(1)) SWIG_fail;
9675 {
9676 arg2 = wxString_in_helper(obj1);
9677 if (arg2 == NULL) SWIG_fail;
9678 temp2 = true;
9679 }
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9683
9684 wxPyEndAllowThreads(__tstate);
9685 if (PyErr_Occurred()) SWIG_fail;
9686 }
9687 {
9688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9689 }
9690 {
9691 if (temp2)
9692 delete arg2;
9693 }
9694 return resultobj;
9695 fail:
9696 {
9697 if (temp2)
9698 delete arg2;
9699 }
9700 return NULL;
9701 }
9702
9703
9704 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9705 PyObject *resultobj;
9706 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9707 wxFileSystem *arg2 = 0 ;
9708 wxString *arg3 = 0 ;
9709 wxFSFile *result;
9710 bool temp3 = false ;
9711 PyObject * obj0 = 0 ;
9712 PyObject * obj1 = 0 ;
9713 PyObject * obj2 = 0 ;
9714 char *kwnames[] = {
9715 (char *) "self",(char *) "fs",(char *) "location", NULL
9716 };
9717
9718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9720 if (SWIG_arg_fail(1)) SWIG_fail;
9721 {
9722 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9723 if (SWIG_arg_fail(2)) SWIG_fail;
9724 if (arg2 == NULL) {
9725 SWIG_null_ref("wxFileSystem");
9726 }
9727 if (SWIG_arg_fail(2)) SWIG_fail;
9728 }
9729 {
9730 arg3 = wxString_in_helper(obj2);
9731 if (arg3 == NULL) SWIG_fail;
9732 temp3 = true;
9733 }
9734 {
9735 PyThreadState* __tstate = wxPyBeginAllowThreads();
9736 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9737
9738 wxPyEndAllowThreads(__tstate);
9739 if (PyErr_Occurred()) SWIG_fail;
9740 }
9741 {
9742 resultobj = wxPyMake_wxObject(result, 1);
9743 }
9744 {
9745 if (temp3)
9746 delete arg3;
9747 }
9748 return resultobj;
9749 fail:
9750 {
9751 if (temp3)
9752 delete arg3;
9753 }
9754 return NULL;
9755 }
9756
9757
9758 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9759 PyObject *resultobj;
9760 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9761 wxString *arg2 = 0 ;
9762 int arg3 = (int) 0 ;
9763 wxString result;
9764 bool temp2 = false ;
9765 PyObject * obj0 = 0 ;
9766 PyObject * obj1 = 0 ;
9767 PyObject * obj2 = 0 ;
9768 char *kwnames[] = {
9769 (char *) "self",(char *) "spec",(char *) "flags", NULL
9770 };
9771
9772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9774 if (SWIG_arg_fail(1)) SWIG_fail;
9775 {
9776 arg2 = wxString_in_helper(obj1);
9777 if (arg2 == NULL) SWIG_fail;
9778 temp2 = true;
9779 }
9780 if (obj2) {
9781 {
9782 arg3 = (int)(SWIG_As_int(obj2));
9783 if (SWIG_arg_fail(3)) SWIG_fail;
9784 }
9785 }
9786 {
9787 PyThreadState* __tstate = wxPyBeginAllowThreads();
9788 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9789
9790 wxPyEndAllowThreads(__tstate);
9791 if (PyErr_Occurred()) SWIG_fail;
9792 }
9793 {
9794 #if wxUSE_UNICODE
9795 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9796 #else
9797 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9798 #endif
9799 }
9800 {
9801 if (temp2)
9802 delete arg2;
9803 }
9804 return resultobj;
9805 fail:
9806 {
9807 if (temp2)
9808 delete arg2;
9809 }
9810 return NULL;
9811 }
9812
9813
9814 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9815 PyObject *resultobj;
9816 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9817 wxString result;
9818 PyObject * obj0 = 0 ;
9819 char *kwnames[] = {
9820 (char *) "self", NULL
9821 };
9822
9823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9825 if (SWIG_arg_fail(1)) SWIG_fail;
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 result = (arg1)->FindNext();
9829
9830 wxPyEndAllowThreads(__tstate);
9831 if (PyErr_Occurred()) SWIG_fail;
9832 }
9833 {
9834 #if wxUSE_UNICODE
9835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9836 #else
9837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9838 #endif
9839 }
9840 return resultobj;
9841 fail:
9842 return NULL;
9843 }
9844
9845
9846 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9847 PyObject *obj;
9848 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9849 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9850 Py_INCREF(obj);
9851 return Py_BuildValue((char *)"");
9852 }
9853 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9854 PyObject *resultobj;
9855 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9856 wxString result;
9857 PyObject * obj0 = 0 ;
9858 char *kwnames[] = {
9859 (char *) "self", NULL
9860 };
9861
9862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9864 if (SWIG_arg_fail(1)) SWIG_fail;
9865 {
9866 PyThreadState* __tstate = wxPyBeginAllowThreads();
9867 result = (arg1)->GetName();
9868
9869 wxPyEndAllowThreads(__tstate);
9870 if (PyErr_Occurred()) SWIG_fail;
9871 }
9872 {
9873 #if wxUSE_UNICODE
9874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9875 #else
9876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9877 #endif
9878 }
9879 return resultobj;
9880 fail:
9881 return NULL;
9882 }
9883
9884
9885 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9886 PyObject *resultobj;
9887 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9888 wxString result;
9889 PyObject * obj0 = 0 ;
9890 char *kwnames[] = {
9891 (char *) "self", NULL
9892 };
9893
9894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9896 if (SWIG_arg_fail(1)) SWIG_fail;
9897 {
9898 PyThreadState* __tstate = wxPyBeginAllowThreads();
9899 result = (arg1)->GetExtension();
9900
9901 wxPyEndAllowThreads(__tstate);
9902 if (PyErr_Occurred()) SWIG_fail;
9903 }
9904 {
9905 #if wxUSE_UNICODE
9906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9907 #else
9908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9909 #endif
9910 }
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9918 PyObject *resultobj;
9919 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9920 long result;
9921 PyObject * obj0 = 0 ;
9922 char *kwnames[] = {
9923 (char *) "self", NULL
9924 };
9925
9926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9928 if (SWIG_arg_fail(1)) SWIG_fail;
9929 {
9930 PyThreadState* __tstate = wxPyBeginAllowThreads();
9931 result = (long)(arg1)->GetType();
9932
9933 wxPyEndAllowThreads(__tstate);
9934 if (PyErr_Occurred()) SWIG_fail;
9935 }
9936 {
9937 resultobj = SWIG_From_long((long)(result));
9938 }
9939 return resultobj;
9940 fail:
9941 return NULL;
9942 }
9943
9944
9945 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9946 PyObject *resultobj;
9947 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9948 wxString result;
9949 PyObject * obj0 = 0 ;
9950 char *kwnames[] = {
9951 (char *) "self", NULL
9952 };
9953
9954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9956 if (SWIG_arg_fail(1)) SWIG_fail;
9957 {
9958 PyThreadState* __tstate = wxPyBeginAllowThreads();
9959 result = (arg1)->GetMimeType();
9960
9961 wxPyEndAllowThreads(__tstate);
9962 if (PyErr_Occurred()) SWIG_fail;
9963 }
9964 {
9965 #if wxUSE_UNICODE
9966 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9967 #else
9968 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9969 #endif
9970 }
9971 return resultobj;
9972 fail:
9973 return NULL;
9974 }
9975
9976
9977 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9978 PyObject *resultobj;
9979 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9980 wxString *arg2 = 0 ;
9981 bool result;
9982 bool temp2 = false ;
9983 PyObject * obj0 = 0 ;
9984 PyObject * obj1 = 0 ;
9985 char *kwnames[] = {
9986 (char *) "self",(char *) "name", NULL
9987 };
9988
9989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9991 if (SWIG_arg_fail(1)) SWIG_fail;
9992 {
9993 arg2 = wxString_in_helper(obj1);
9994 if (arg2 == NULL) SWIG_fail;
9995 temp2 = true;
9996 }
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10000
10001 wxPyEndAllowThreads(__tstate);
10002 if (PyErr_Occurred()) SWIG_fail;
10003 }
10004 {
10005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10006 }
10007 {
10008 if (temp2)
10009 delete arg2;
10010 }
10011 return resultobj;
10012 fail:
10013 {
10014 if (temp2)
10015 delete arg2;
10016 }
10017 return NULL;
10018 }
10019
10020
10021 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10022 PyObject *resultobj;
10023 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10024 wxString *arg2 = 0 ;
10025 bool temp2 = false ;
10026 PyObject * obj0 = 0 ;
10027 PyObject * obj1 = 0 ;
10028 char *kwnames[] = {
10029 (char *) "self",(char *) "name", NULL
10030 };
10031
10032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10034 if (SWIG_arg_fail(1)) SWIG_fail;
10035 {
10036 arg2 = wxString_in_helper(obj1);
10037 if (arg2 == NULL) SWIG_fail;
10038 temp2 = true;
10039 }
10040 {
10041 PyThreadState* __tstate = wxPyBeginAllowThreads();
10042 (arg1)->SetName((wxString const &)*arg2);
10043
10044 wxPyEndAllowThreads(__tstate);
10045 if (PyErr_Occurred()) SWIG_fail;
10046 }
10047 Py_INCREF(Py_None); resultobj = Py_None;
10048 {
10049 if (temp2)
10050 delete arg2;
10051 }
10052 return resultobj;
10053 fail:
10054 {
10055 if (temp2)
10056 delete arg2;
10057 }
10058 return NULL;
10059 }
10060
10061
10062 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10063 PyObject *resultobj;
10064 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10065 wxString *arg2 = 0 ;
10066 bool temp2 = false ;
10067 PyObject * obj0 = 0 ;
10068 PyObject * obj1 = 0 ;
10069 char *kwnames[] = {
10070 (char *) "self",(char *) "extension", NULL
10071 };
10072
10073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",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 (arg1)->SetExtension((wxString const &)*arg2);
10084
10085 wxPyEndAllowThreads(__tstate);
10086 if (PyErr_Occurred()) SWIG_fail;
10087 }
10088 Py_INCREF(Py_None); resultobj = Py_None;
10089 {
10090 if (temp2)
10091 delete arg2;
10092 }
10093 return resultobj;
10094 fail:
10095 {
10096 if (temp2)
10097 delete arg2;
10098 }
10099 return NULL;
10100 }
10101
10102
10103 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj;
10105 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10106 long arg2 ;
10107 PyObject * obj0 = 0 ;
10108 PyObject * obj1 = 0 ;
10109 char *kwnames[] = {
10110 (char *) "self",(char *) "type", NULL
10111 };
10112
10113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10115 if (SWIG_arg_fail(1)) SWIG_fail;
10116 {
10117 arg2 = (long)(SWIG_As_long(obj1));
10118 if (SWIG_arg_fail(2)) SWIG_fail;
10119 }
10120 {
10121 PyThreadState* __tstate = wxPyBeginAllowThreads();
10122 (arg1)->SetType(arg2);
10123
10124 wxPyEndAllowThreads(__tstate);
10125 if (PyErr_Occurred()) SWIG_fail;
10126 }
10127 Py_INCREF(Py_None); resultobj = Py_None;
10128 return resultobj;
10129 fail:
10130 return NULL;
10131 }
10132
10133
10134 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10135 PyObject *resultobj;
10136 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10137 wxString *arg2 = 0 ;
10138 bool temp2 = false ;
10139 PyObject * obj0 = 0 ;
10140 PyObject * obj1 = 0 ;
10141 char *kwnames[] = {
10142 (char *) "self",(char *) "mimetype", NULL
10143 };
10144
10145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10147 if (SWIG_arg_fail(1)) SWIG_fail;
10148 {
10149 arg2 = wxString_in_helper(obj1);
10150 if (arg2 == NULL) SWIG_fail;
10151 temp2 = true;
10152 }
10153 {
10154 PyThreadState* __tstate = wxPyBeginAllowThreads();
10155 (arg1)->SetMimeType((wxString const &)*arg2);
10156
10157 wxPyEndAllowThreads(__tstate);
10158 if (PyErr_Occurred()) SWIG_fail;
10159 }
10160 Py_INCREF(Py_None); resultobj = Py_None;
10161 {
10162 if (temp2)
10163 delete arg2;
10164 }
10165 return resultobj;
10166 fail:
10167 {
10168 if (temp2)
10169 delete arg2;
10170 }
10171 return NULL;
10172 }
10173
10174
10175 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10176 PyObject *obj;
10177 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10178 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10179 Py_INCREF(obj);
10180 return Py_BuildValue((char *)"");
10181 }
10182 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10183 PyObject *resultobj;
10184 wxImageHistogram *result;
10185 char *kwnames[] = {
10186 NULL
10187 };
10188
10189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10190 {
10191 PyThreadState* __tstate = wxPyBeginAllowThreads();
10192 result = (wxImageHistogram *)new wxImageHistogram();
10193
10194 wxPyEndAllowThreads(__tstate);
10195 if (PyErr_Occurred()) SWIG_fail;
10196 }
10197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10198 return resultobj;
10199 fail:
10200 return NULL;
10201 }
10202
10203
10204 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10205 PyObject *resultobj;
10206 unsigned char arg1 ;
10207 unsigned char arg2 ;
10208 unsigned char arg3 ;
10209 unsigned long result;
10210 PyObject * obj0 = 0 ;
10211 PyObject * obj1 = 0 ;
10212 PyObject * obj2 = 0 ;
10213 char *kwnames[] = {
10214 (char *) "r",(char *) "g",(char *) "b", NULL
10215 };
10216
10217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10218 {
10219 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10220 if (SWIG_arg_fail(1)) SWIG_fail;
10221 }
10222 {
10223 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10224 if (SWIG_arg_fail(2)) SWIG_fail;
10225 }
10226 {
10227 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10228 if (SWIG_arg_fail(3)) SWIG_fail;
10229 }
10230 {
10231 PyThreadState* __tstate = wxPyBeginAllowThreads();
10232 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10233
10234 wxPyEndAllowThreads(__tstate);
10235 if (PyErr_Occurred()) SWIG_fail;
10236 }
10237 {
10238 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10239 }
10240 return resultobj;
10241 fail:
10242 return NULL;
10243 }
10244
10245
10246 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10247 PyObject *resultobj;
10248 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10249 unsigned char *arg2 = (unsigned char *) 0 ;
10250 unsigned char *arg3 = (unsigned char *) 0 ;
10251 unsigned char *arg4 = (unsigned char *) 0 ;
10252 unsigned char arg5 = (unsigned char) 1 ;
10253 unsigned char arg6 = (unsigned char) 0 ;
10254 unsigned char arg7 = (unsigned char) 0 ;
10255 bool result;
10256 unsigned char temp2 ;
10257 int res2 = 0 ;
10258 unsigned char temp3 ;
10259 int res3 = 0 ;
10260 unsigned char temp4 ;
10261 int res4 = 0 ;
10262 PyObject * obj0 = 0 ;
10263 PyObject * obj1 = 0 ;
10264 PyObject * obj2 = 0 ;
10265 PyObject * obj3 = 0 ;
10266 char *kwnames[] = {
10267 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10268 };
10269
10270 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10271 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10272 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10275 if (SWIG_arg_fail(1)) SWIG_fail;
10276 if (obj1) {
10277 {
10278 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10279 if (SWIG_arg_fail(5)) SWIG_fail;
10280 }
10281 }
10282 if (obj2) {
10283 {
10284 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10285 if (SWIG_arg_fail(6)) SWIG_fail;
10286 }
10287 }
10288 if (obj3) {
10289 {
10290 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10291 if (SWIG_arg_fail(7)) SWIG_fail;
10292 }
10293 }
10294 {
10295 PyThreadState* __tstate = wxPyBeginAllowThreads();
10296 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10297
10298 wxPyEndAllowThreads(__tstate);
10299 if (PyErr_Occurred()) SWIG_fail;
10300 }
10301 {
10302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10303 }
10304 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10305 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10306 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10307 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10308 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10309 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10310 return resultobj;
10311 fail:
10312 return NULL;
10313 }
10314
10315
10316 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10317 PyObject *obj;
10318 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10319 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10320 Py_INCREF(obj);
10321 return Py_BuildValue((char *)"");
10322 }
10323 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10324 PyObject *resultobj;
10325 wxString *arg1 = 0 ;
10326 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10327 int arg3 = (int) -1 ;
10328 wxImage *result;
10329 bool temp1 = false ;
10330 PyObject * obj0 = 0 ;
10331 PyObject * obj1 = 0 ;
10332 PyObject * obj2 = 0 ;
10333 char *kwnames[] = {
10334 (char *) "name",(char *) "type",(char *) "index", NULL
10335 };
10336
10337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10338 {
10339 arg1 = wxString_in_helper(obj0);
10340 if (arg1 == NULL) SWIG_fail;
10341 temp1 = true;
10342 }
10343 if (obj1) {
10344 {
10345 arg2 = (long)(SWIG_As_long(obj1));
10346 if (SWIG_arg_fail(2)) SWIG_fail;
10347 }
10348 }
10349 if (obj2) {
10350 {
10351 arg3 = (int)(SWIG_As_int(obj2));
10352 if (SWIG_arg_fail(3)) SWIG_fail;
10353 }
10354 }
10355 {
10356 PyThreadState* __tstate = wxPyBeginAllowThreads();
10357 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10358
10359 wxPyEndAllowThreads(__tstate);
10360 if (PyErr_Occurred()) SWIG_fail;
10361 }
10362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10363 {
10364 if (temp1)
10365 delete arg1;
10366 }
10367 return resultobj;
10368 fail:
10369 {
10370 if (temp1)
10371 delete arg1;
10372 }
10373 return NULL;
10374 }
10375
10376
10377 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10378 PyObject *resultobj;
10379 wxImage *arg1 = (wxImage *) 0 ;
10380 PyObject * obj0 = 0 ;
10381 char *kwnames[] = {
10382 (char *) "self", NULL
10383 };
10384
10385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10387 if (SWIG_arg_fail(1)) SWIG_fail;
10388 {
10389 PyThreadState* __tstate = wxPyBeginAllowThreads();
10390 delete arg1;
10391
10392 wxPyEndAllowThreads(__tstate);
10393 if (PyErr_Occurred()) SWIG_fail;
10394 }
10395 Py_INCREF(Py_None); resultobj = Py_None;
10396 return resultobj;
10397 fail:
10398 return NULL;
10399 }
10400
10401
10402 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10403 PyObject *resultobj;
10404 wxString *arg1 = 0 ;
10405 wxString *arg2 = 0 ;
10406 int arg3 = (int) -1 ;
10407 wxImage *result;
10408 bool temp1 = false ;
10409 bool temp2 = false ;
10410 PyObject * obj0 = 0 ;
10411 PyObject * obj1 = 0 ;
10412 PyObject * obj2 = 0 ;
10413 char *kwnames[] = {
10414 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10415 };
10416
10417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10418 {
10419 arg1 = wxString_in_helper(obj0);
10420 if (arg1 == NULL) SWIG_fail;
10421 temp1 = true;
10422 }
10423 {
10424 arg2 = wxString_in_helper(obj1);
10425 if (arg2 == NULL) SWIG_fail;
10426 temp2 = true;
10427 }
10428 if (obj2) {
10429 {
10430 arg3 = (int)(SWIG_As_int(obj2));
10431 if (SWIG_arg_fail(3)) SWIG_fail;
10432 }
10433 }
10434 {
10435 PyThreadState* __tstate = wxPyBeginAllowThreads();
10436 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10437
10438 wxPyEndAllowThreads(__tstate);
10439 if (PyErr_Occurred()) SWIG_fail;
10440 }
10441 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10442 {
10443 if (temp1)
10444 delete arg1;
10445 }
10446 {
10447 if (temp2)
10448 delete arg2;
10449 }
10450 return resultobj;
10451 fail:
10452 {
10453 if (temp1)
10454 delete arg1;
10455 }
10456 {
10457 if (temp2)
10458 delete arg2;
10459 }
10460 return NULL;
10461 }
10462
10463
10464 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10465 PyObject *resultobj;
10466 wxInputStream *arg1 = 0 ;
10467 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10468 int arg3 = (int) -1 ;
10469 wxImage *result;
10470 wxPyInputStream *temp1 ;
10471 bool created1 ;
10472 PyObject * obj0 = 0 ;
10473 PyObject * obj1 = 0 ;
10474 PyObject * obj2 = 0 ;
10475 char *kwnames[] = {
10476 (char *) "stream",(char *) "type",(char *) "index", NULL
10477 };
10478
10479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10480 {
10481 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10482 arg1 = temp1->m_wxis;
10483 created1 = false;
10484 } else {
10485 PyErr_Clear(); // clear the failure of the wxPyConvert above
10486 arg1 = wxPyCBInputStream_create(obj0, false);
10487 if (arg1 == NULL) {
10488 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10489 SWIG_fail;
10490 }
10491 created1 = true;
10492 }
10493 }
10494 if (obj1) {
10495 {
10496 arg2 = (long)(SWIG_As_long(obj1));
10497 if (SWIG_arg_fail(2)) SWIG_fail;
10498 }
10499 }
10500 if (obj2) {
10501 {
10502 arg3 = (int)(SWIG_As_int(obj2));
10503 if (SWIG_arg_fail(3)) SWIG_fail;
10504 }
10505 }
10506 {
10507 PyThreadState* __tstate = wxPyBeginAllowThreads();
10508 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10509
10510 wxPyEndAllowThreads(__tstate);
10511 if (PyErr_Occurred()) SWIG_fail;
10512 }
10513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10514 {
10515 if (created1)
10516 delete arg1;
10517 }
10518 return resultobj;
10519 fail:
10520 {
10521 if (created1)
10522 delete arg1;
10523 }
10524 return NULL;
10525 }
10526
10527
10528 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10529 PyObject *resultobj;
10530 wxInputStream *arg1 = 0 ;
10531 wxString *arg2 = 0 ;
10532 int arg3 = (int) -1 ;
10533 wxImage *result;
10534 wxPyInputStream *temp1 ;
10535 bool created1 ;
10536 bool temp2 = false ;
10537 PyObject * obj0 = 0 ;
10538 PyObject * obj1 = 0 ;
10539 PyObject * obj2 = 0 ;
10540 char *kwnames[] = {
10541 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10542 };
10543
10544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10545 {
10546 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10547 arg1 = temp1->m_wxis;
10548 created1 = false;
10549 } else {
10550 PyErr_Clear(); // clear the failure of the wxPyConvert above
10551 arg1 = wxPyCBInputStream_create(obj0, false);
10552 if (arg1 == NULL) {
10553 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10554 SWIG_fail;
10555 }
10556 created1 = true;
10557 }
10558 }
10559 {
10560 arg2 = wxString_in_helper(obj1);
10561 if (arg2 == NULL) SWIG_fail;
10562 temp2 = true;
10563 }
10564 if (obj2) {
10565 {
10566 arg3 = (int)(SWIG_As_int(obj2));
10567 if (SWIG_arg_fail(3)) SWIG_fail;
10568 }
10569 }
10570 {
10571 PyThreadState* __tstate = wxPyBeginAllowThreads();
10572 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10573
10574 wxPyEndAllowThreads(__tstate);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10578 {
10579 if (created1)
10580 delete arg1;
10581 }
10582 {
10583 if (temp2)
10584 delete arg2;
10585 }
10586 return resultobj;
10587 fail:
10588 {
10589 if (created1)
10590 delete arg1;
10591 }
10592 {
10593 if (temp2)
10594 delete arg2;
10595 }
10596 return NULL;
10597 }
10598
10599
10600 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10601 PyObject *resultobj;
10602 int arg1 = (int) 0 ;
10603 int arg2 = (int) 0 ;
10604 bool arg3 = (bool) true ;
10605 wxImage *result;
10606 PyObject * obj0 = 0 ;
10607 PyObject * obj1 = 0 ;
10608 PyObject * obj2 = 0 ;
10609 char *kwnames[] = {
10610 (char *) "width",(char *) "height",(char *) "clear", NULL
10611 };
10612
10613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10614 if (obj0) {
10615 {
10616 arg1 = (int)(SWIG_As_int(obj0));
10617 if (SWIG_arg_fail(1)) SWIG_fail;
10618 }
10619 }
10620 if (obj1) {
10621 {
10622 arg2 = (int)(SWIG_As_int(obj1));
10623 if (SWIG_arg_fail(2)) SWIG_fail;
10624 }
10625 }
10626 if (obj2) {
10627 {
10628 arg3 = (bool)(SWIG_As_bool(obj2));
10629 if (SWIG_arg_fail(3)) SWIG_fail;
10630 }
10631 }
10632 {
10633 PyThreadState* __tstate = wxPyBeginAllowThreads();
10634 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10635
10636 wxPyEndAllowThreads(__tstate);
10637 if (PyErr_Occurred()) SWIG_fail;
10638 }
10639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10640 return resultobj;
10641 fail:
10642 return NULL;
10643 }
10644
10645
10646 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10647 PyObject *resultobj;
10648 wxBitmap *arg1 = 0 ;
10649 wxImage *result;
10650 PyObject * obj0 = 0 ;
10651 char *kwnames[] = {
10652 (char *) "bitmap", NULL
10653 };
10654
10655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10656 {
10657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10658 if (SWIG_arg_fail(1)) SWIG_fail;
10659 if (arg1 == NULL) {
10660 SWIG_null_ref("wxBitmap");
10661 }
10662 if (SWIG_arg_fail(1)) SWIG_fail;
10663 }
10664 {
10665 if (!wxPyCheckForApp()) SWIG_fail;
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10668
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10680 PyObject *resultobj;
10681 int arg1 ;
10682 int arg2 ;
10683 unsigned char *arg3 = (unsigned char *) 0 ;
10684 wxImage *result;
10685 PyObject * obj0 = 0 ;
10686 PyObject * obj1 = 0 ;
10687 PyObject * obj2 = 0 ;
10688 char *kwnames[] = {
10689 (char *) "width",(char *) "height",(char *) "data", NULL
10690 };
10691
10692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10693 {
10694 arg1 = (int)(SWIG_As_int(obj0));
10695 if (SWIG_arg_fail(1)) SWIG_fail;
10696 }
10697 {
10698 arg2 = (int)(SWIG_As_int(obj1));
10699 if (SWIG_arg_fail(2)) SWIG_fail;
10700 }
10701 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10702 if (SWIG_arg_fail(3)) SWIG_fail;
10703 {
10704 PyThreadState* __tstate = wxPyBeginAllowThreads();
10705 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10706
10707 wxPyEndAllowThreads(__tstate);
10708 if (PyErr_Occurred()) SWIG_fail;
10709 }
10710 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10711 return resultobj;
10712 fail:
10713 return NULL;
10714 }
10715
10716
10717 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10718 PyObject *resultobj;
10719 int arg1 ;
10720 int arg2 ;
10721 unsigned char *arg3 = (unsigned char *) 0 ;
10722 unsigned char *arg4 = (unsigned char *) 0 ;
10723 wxImage *result;
10724 PyObject * obj0 = 0 ;
10725 PyObject * obj1 = 0 ;
10726 PyObject * obj2 = 0 ;
10727 PyObject * obj3 = 0 ;
10728 char *kwnames[] = {
10729 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10730 };
10731
10732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10733 {
10734 arg1 = (int)(SWIG_As_int(obj0));
10735 if (SWIG_arg_fail(1)) SWIG_fail;
10736 }
10737 {
10738 arg2 = (int)(SWIG_As_int(obj1));
10739 if (SWIG_arg_fail(2)) SWIG_fail;
10740 }
10741 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10742 if (SWIG_arg_fail(3)) SWIG_fail;
10743 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10744 if (SWIG_arg_fail(4)) SWIG_fail;
10745 {
10746 PyThreadState* __tstate = wxPyBeginAllowThreads();
10747 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10748
10749 wxPyEndAllowThreads(__tstate);
10750 if (PyErr_Occurred()) SWIG_fail;
10751 }
10752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10753 return resultobj;
10754 fail:
10755 return NULL;
10756 }
10757
10758
10759 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10760 PyObject *resultobj;
10761 wxImage *arg1 = (wxImage *) 0 ;
10762 int arg2 ;
10763 int arg3 ;
10764 PyObject * obj0 = 0 ;
10765 PyObject * obj1 = 0 ;
10766 PyObject * obj2 = 0 ;
10767 char *kwnames[] = {
10768 (char *) "self",(char *) "width",(char *) "height", NULL
10769 };
10770
10771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10773 if (SWIG_arg_fail(1)) SWIG_fail;
10774 {
10775 arg2 = (int)(SWIG_As_int(obj1));
10776 if (SWIG_arg_fail(2)) SWIG_fail;
10777 }
10778 {
10779 arg3 = (int)(SWIG_As_int(obj2));
10780 if (SWIG_arg_fail(3)) SWIG_fail;
10781 }
10782 {
10783 PyThreadState* __tstate = wxPyBeginAllowThreads();
10784 (arg1)->Create(arg2,arg3);
10785
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 Py_INCREF(Py_None); resultobj = Py_None;
10790 return resultobj;
10791 fail:
10792 return NULL;
10793 }
10794
10795
10796 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10797 PyObject *resultobj;
10798 wxImage *arg1 = (wxImage *) 0 ;
10799 PyObject * obj0 = 0 ;
10800 char *kwnames[] = {
10801 (char *) "self", NULL
10802 };
10803
10804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10806 if (SWIG_arg_fail(1)) SWIG_fail;
10807 {
10808 PyThreadState* __tstate = wxPyBeginAllowThreads();
10809 (arg1)->Destroy();
10810
10811 wxPyEndAllowThreads(__tstate);
10812 if (PyErr_Occurred()) SWIG_fail;
10813 }
10814 Py_INCREF(Py_None); resultobj = Py_None;
10815 return resultobj;
10816 fail:
10817 return NULL;
10818 }
10819
10820
10821 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10822 PyObject *resultobj;
10823 wxImage *arg1 = (wxImage *) 0 ;
10824 int arg2 ;
10825 int arg3 ;
10826 SwigValueWrapper<wxImage > result;
10827 PyObject * obj0 = 0 ;
10828 PyObject * obj1 = 0 ;
10829 PyObject * obj2 = 0 ;
10830 char *kwnames[] = {
10831 (char *) "self",(char *) "width",(char *) "height", NULL
10832 };
10833
10834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10836 if (SWIG_arg_fail(1)) SWIG_fail;
10837 {
10838 arg2 = (int)(SWIG_As_int(obj1));
10839 if (SWIG_arg_fail(2)) SWIG_fail;
10840 }
10841 {
10842 arg3 = (int)(SWIG_As_int(obj2));
10843 if (SWIG_arg_fail(3)) SWIG_fail;
10844 }
10845 {
10846 PyThreadState* __tstate = wxPyBeginAllowThreads();
10847 result = (arg1)->Scale(arg2,arg3);
10848
10849 wxPyEndAllowThreads(__tstate);
10850 if (PyErr_Occurred()) SWIG_fail;
10851 }
10852 {
10853 wxImage * resultptr;
10854 resultptr = new wxImage((wxImage &)(result));
10855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10856 }
10857 return resultobj;
10858 fail:
10859 return NULL;
10860 }
10861
10862
10863 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10864 PyObject *resultobj;
10865 wxImage *arg1 = (wxImage *) 0 ;
10866 int arg2 ;
10867 int arg3 ;
10868 SwigValueWrapper<wxImage > result;
10869 PyObject * obj0 = 0 ;
10870 PyObject * obj1 = 0 ;
10871 PyObject * obj2 = 0 ;
10872 char *kwnames[] = {
10873 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10874 };
10875
10876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10878 if (SWIG_arg_fail(1)) SWIG_fail;
10879 {
10880 arg2 = (int)(SWIG_As_int(obj1));
10881 if (SWIG_arg_fail(2)) SWIG_fail;
10882 }
10883 {
10884 arg3 = (int)(SWIG_As_int(obj2));
10885 if (SWIG_arg_fail(3)) SWIG_fail;
10886 }
10887 {
10888 PyThreadState* __tstate = wxPyBeginAllowThreads();
10889 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10890
10891 wxPyEndAllowThreads(__tstate);
10892 if (PyErr_Occurred()) SWIG_fail;
10893 }
10894 {
10895 wxImage * resultptr;
10896 resultptr = new wxImage((wxImage &)(result));
10897 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10898 }
10899 return resultobj;
10900 fail:
10901 return NULL;
10902 }
10903
10904
10905 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10906 PyObject *resultobj;
10907 wxImage *arg1 = (wxImage *) 0 ;
10908 int arg2 ;
10909 int arg3 ;
10910 wxImage *result;
10911 PyObject * obj0 = 0 ;
10912 PyObject * obj1 = 0 ;
10913 PyObject * obj2 = 0 ;
10914 char *kwnames[] = {
10915 (char *) "self",(char *) "width",(char *) "height", NULL
10916 };
10917
10918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10920 if (SWIG_arg_fail(1)) SWIG_fail;
10921 {
10922 arg2 = (int)(SWIG_As_int(obj1));
10923 if (SWIG_arg_fail(2)) SWIG_fail;
10924 }
10925 {
10926 arg3 = (int)(SWIG_As_int(obj2));
10927 if (SWIG_arg_fail(3)) SWIG_fail;
10928 }
10929 {
10930 PyThreadState* __tstate = wxPyBeginAllowThreads();
10931 {
10932 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10933 result = (wxImage *) &_result_ref;
10934 }
10935
10936 wxPyEndAllowThreads(__tstate);
10937 if (PyErr_Occurred()) SWIG_fail;
10938 }
10939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10940 return resultobj;
10941 fail:
10942 return NULL;
10943 }
10944
10945
10946 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10947 PyObject *resultobj;
10948 wxImage *arg1 = (wxImage *) 0 ;
10949 int arg2 ;
10950 int arg3 ;
10951 unsigned char arg4 ;
10952 unsigned char arg5 ;
10953 unsigned char arg6 ;
10954 PyObject * obj0 = 0 ;
10955 PyObject * obj1 = 0 ;
10956 PyObject * obj2 = 0 ;
10957 PyObject * obj3 = 0 ;
10958 PyObject * obj4 = 0 ;
10959 PyObject * obj5 = 0 ;
10960 char *kwnames[] = {
10961 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10962 };
10963
10964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10966 if (SWIG_arg_fail(1)) SWIG_fail;
10967 {
10968 arg2 = (int)(SWIG_As_int(obj1));
10969 if (SWIG_arg_fail(2)) SWIG_fail;
10970 }
10971 {
10972 arg3 = (int)(SWIG_As_int(obj2));
10973 if (SWIG_arg_fail(3)) SWIG_fail;
10974 }
10975 {
10976 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10977 if (SWIG_arg_fail(4)) SWIG_fail;
10978 }
10979 {
10980 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10981 if (SWIG_arg_fail(5)) SWIG_fail;
10982 }
10983 {
10984 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10985 if (SWIG_arg_fail(6)) SWIG_fail;
10986 }
10987 {
10988 PyThreadState* __tstate = wxPyBeginAllowThreads();
10989 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10990
10991 wxPyEndAllowThreads(__tstate);
10992 if (PyErr_Occurred()) SWIG_fail;
10993 }
10994 Py_INCREF(Py_None); resultobj = Py_None;
10995 return resultobj;
10996 fail:
10997 return NULL;
10998 }
10999
11000
11001 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11002 PyObject *resultobj;
11003 wxImage *arg1 = (wxImage *) 0 ;
11004 int arg2 ;
11005 int arg3 ;
11006 unsigned char result;
11007 PyObject * obj0 = 0 ;
11008 PyObject * obj1 = 0 ;
11009 PyObject * obj2 = 0 ;
11010 char *kwnames[] = {
11011 (char *) "self",(char *) "x",(char *) "y", NULL
11012 };
11013
11014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11016 if (SWIG_arg_fail(1)) SWIG_fail;
11017 {
11018 arg2 = (int)(SWIG_As_int(obj1));
11019 if (SWIG_arg_fail(2)) SWIG_fail;
11020 }
11021 {
11022 arg3 = (int)(SWIG_As_int(obj2));
11023 if (SWIG_arg_fail(3)) SWIG_fail;
11024 }
11025 {
11026 PyThreadState* __tstate = wxPyBeginAllowThreads();
11027 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11028
11029 wxPyEndAllowThreads(__tstate);
11030 if (PyErr_Occurred()) SWIG_fail;
11031 }
11032 {
11033 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11034 }
11035 return resultobj;
11036 fail:
11037 return NULL;
11038 }
11039
11040
11041 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11042 PyObject *resultobj;
11043 wxImage *arg1 = (wxImage *) 0 ;
11044 int arg2 ;
11045 int arg3 ;
11046 unsigned char result;
11047 PyObject * obj0 = 0 ;
11048 PyObject * obj1 = 0 ;
11049 PyObject * obj2 = 0 ;
11050 char *kwnames[] = {
11051 (char *) "self",(char *) "x",(char *) "y", NULL
11052 };
11053
11054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11056 if (SWIG_arg_fail(1)) SWIG_fail;
11057 {
11058 arg2 = (int)(SWIG_As_int(obj1));
11059 if (SWIG_arg_fail(2)) SWIG_fail;
11060 }
11061 {
11062 arg3 = (int)(SWIG_As_int(obj2));
11063 if (SWIG_arg_fail(3)) SWIG_fail;
11064 }
11065 {
11066 PyThreadState* __tstate = wxPyBeginAllowThreads();
11067 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11068
11069 wxPyEndAllowThreads(__tstate);
11070 if (PyErr_Occurred()) SWIG_fail;
11071 }
11072 {
11073 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11074 }
11075 return resultobj;
11076 fail:
11077 return NULL;
11078 }
11079
11080
11081 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11082 PyObject *resultobj;
11083 wxImage *arg1 = (wxImage *) 0 ;
11084 int arg2 ;
11085 int arg3 ;
11086 unsigned char result;
11087 PyObject * obj0 = 0 ;
11088 PyObject * obj1 = 0 ;
11089 PyObject * obj2 = 0 ;
11090 char *kwnames[] = {
11091 (char *) "self",(char *) "x",(char *) "y", NULL
11092 };
11093
11094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11096 if (SWIG_arg_fail(1)) SWIG_fail;
11097 {
11098 arg2 = (int)(SWIG_As_int(obj1));
11099 if (SWIG_arg_fail(2)) SWIG_fail;
11100 }
11101 {
11102 arg3 = (int)(SWIG_As_int(obj2));
11103 if (SWIG_arg_fail(3)) SWIG_fail;
11104 }
11105 {
11106 PyThreadState* __tstate = wxPyBeginAllowThreads();
11107 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11108
11109 wxPyEndAllowThreads(__tstate);
11110 if (PyErr_Occurred()) SWIG_fail;
11111 }
11112 {
11113 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11114 }
11115 return resultobj;
11116 fail:
11117 return NULL;
11118 }
11119
11120
11121 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11122 PyObject *resultobj;
11123 wxImage *arg1 = (wxImage *) 0 ;
11124 int arg2 ;
11125 int arg3 ;
11126 unsigned char arg4 ;
11127 PyObject * obj0 = 0 ;
11128 PyObject * obj1 = 0 ;
11129 PyObject * obj2 = 0 ;
11130 PyObject * obj3 = 0 ;
11131 char *kwnames[] = {
11132 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11133 };
11134
11135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11137 if (SWIG_arg_fail(1)) SWIG_fail;
11138 {
11139 arg2 = (int)(SWIG_As_int(obj1));
11140 if (SWIG_arg_fail(2)) SWIG_fail;
11141 }
11142 {
11143 arg3 = (int)(SWIG_As_int(obj2));
11144 if (SWIG_arg_fail(3)) SWIG_fail;
11145 }
11146 {
11147 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11148 if (SWIG_arg_fail(4)) SWIG_fail;
11149 }
11150 {
11151 PyThreadState* __tstate = wxPyBeginAllowThreads();
11152 (arg1)->SetAlpha(arg2,arg3,arg4);
11153
11154 wxPyEndAllowThreads(__tstate);
11155 if (PyErr_Occurred()) SWIG_fail;
11156 }
11157 Py_INCREF(Py_None); resultobj = Py_None;
11158 return resultobj;
11159 fail:
11160 return NULL;
11161 }
11162
11163
11164 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11165 PyObject *resultobj;
11166 wxImage *arg1 = (wxImage *) 0 ;
11167 int arg2 ;
11168 int arg3 ;
11169 unsigned char result;
11170 PyObject * obj0 = 0 ;
11171 PyObject * obj1 = 0 ;
11172 PyObject * obj2 = 0 ;
11173 char *kwnames[] = {
11174 (char *) "self",(char *) "x",(char *) "y", NULL
11175 };
11176
11177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11179 if (SWIG_arg_fail(1)) SWIG_fail;
11180 {
11181 arg2 = (int)(SWIG_As_int(obj1));
11182 if (SWIG_arg_fail(2)) SWIG_fail;
11183 }
11184 {
11185 arg3 = (int)(SWIG_As_int(obj2));
11186 if (SWIG_arg_fail(3)) SWIG_fail;
11187 }
11188 {
11189 PyThreadState* __tstate = wxPyBeginAllowThreads();
11190 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11191
11192 wxPyEndAllowThreads(__tstate);
11193 if (PyErr_Occurred()) SWIG_fail;
11194 }
11195 {
11196 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11197 }
11198 return resultobj;
11199 fail:
11200 return NULL;
11201 }
11202
11203
11204 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11205 PyObject *resultobj;
11206 wxImage *arg1 = (wxImage *) 0 ;
11207 bool result;
11208 PyObject * obj0 = 0 ;
11209 char *kwnames[] = {
11210 (char *) "self", NULL
11211 };
11212
11213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11215 if (SWIG_arg_fail(1)) SWIG_fail;
11216 {
11217 PyThreadState* __tstate = wxPyBeginAllowThreads();
11218 result = (bool)(arg1)->HasAlpha();
11219
11220 wxPyEndAllowThreads(__tstate);
11221 if (PyErr_Occurred()) SWIG_fail;
11222 }
11223 {
11224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11225 }
11226 return resultobj;
11227 fail:
11228 return NULL;
11229 }
11230
11231
11232 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11233 PyObject *resultobj;
11234 wxImage *arg1 = (wxImage *) 0 ;
11235 PyObject * obj0 = 0 ;
11236 char *kwnames[] = {
11237 (char *) "self", NULL
11238 };
11239
11240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11242 if (SWIG_arg_fail(1)) SWIG_fail;
11243 {
11244 PyThreadState* __tstate = wxPyBeginAllowThreads();
11245 (arg1)->InitAlpha();
11246
11247 wxPyEndAllowThreads(__tstate);
11248 if (PyErr_Occurred()) SWIG_fail;
11249 }
11250 Py_INCREF(Py_None); resultobj = Py_None;
11251 return resultobj;
11252 fail:
11253 return NULL;
11254 }
11255
11256
11257 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11258 PyObject *resultobj;
11259 wxImage *arg1 = (wxImage *) 0 ;
11260 byte *arg2 = (byte *) 0 ;
11261 byte *arg3 = (byte *) 0 ;
11262 byte *arg4 = (byte *) 0 ;
11263 byte arg5 = (byte) 0 ;
11264 byte arg6 = (byte) 0 ;
11265 byte arg7 = (byte) 0 ;
11266 bool result;
11267 byte temp2 ;
11268 int res2 = 0 ;
11269 byte temp3 ;
11270 int res3 = 0 ;
11271 byte temp4 ;
11272 int res4 = 0 ;
11273 PyObject * obj0 = 0 ;
11274 PyObject * obj1 = 0 ;
11275 PyObject * obj2 = 0 ;
11276 PyObject * obj3 = 0 ;
11277 char *kwnames[] = {
11278 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11279 };
11280
11281 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11282 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11283 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11286 if (SWIG_arg_fail(1)) SWIG_fail;
11287 if (obj1) {
11288 {
11289 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11290 if (SWIG_arg_fail(5)) SWIG_fail;
11291 }
11292 }
11293 if (obj2) {
11294 {
11295 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11296 if (SWIG_arg_fail(6)) SWIG_fail;
11297 }
11298 }
11299 if (obj3) {
11300 {
11301 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11302 if (SWIG_arg_fail(7)) SWIG_fail;
11303 }
11304 }
11305 {
11306 PyThreadState* __tstate = wxPyBeginAllowThreads();
11307 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11308
11309 wxPyEndAllowThreads(__tstate);
11310 if (PyErr_Occurred()) SWIG_fail;
11311 }
11312 {
11313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11314 }
11315 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11316 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11317 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11318 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11319 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11320 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11321 return resultobj;
11322 fail:
11323 return NULL;
11324 }
11325
11326
11327 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11328 PyObject *resultobj;
11329 wxImage *arg1 = (wxImage *) 0 ;
11330 byte arg2 = (byte) 128 ;
11331 bool result;
11332 PyObject * obj0 = 0 ;
11333 PyObject * obj1 = 0 ;
11334 char *kwnames[] = {
11335 (char *) "self",(char *) "threshold", NULL
11336 };
11337
11338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11340 if (SWIG_arg_fail(1)) SWIG_fail;
11341 if (obj1) {
11342 {
11343 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11344 if (SWIG_arg_fail(2)) SWIG_fail;
11345 }
11346 }
11347 {
11348 PyThreadState* __tstate = wxPyBeginAllowThreads();
11349 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11350
11351 wxPyEndAllowThreads(__tstate);
11352 if (PyErr_Occurred()) SWIG_fail;
11353 }
11354 {
11355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11356 }
11357 return resultobj;
11358 fail:
11359 return NULL;
11360 }
11361
11362
11363 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11364 PyObject *resultobj;
11365 wxImage *arg1 = (wxImage *) 0 ;
11366 unsigned char arg2 ;
11367 unsigned char arg3 ;
11368 unsigned char arg4 ;
11369 bool result;
11370 PyObject * obj0 = 0 ;
11371 PyObject * obj1 = 0 ;
11372 PyObject * obj2 = 0 ;
11373 PyObject * obj3 = 0 ;
11374 char *kwnames[] = {
11375 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11376 };
11377
11378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11380 if (SWIG_arg_fail(1)) SWIG_fail;
11381 {
11382 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11383 if (SWIG_arg_fail(2)) SWIG_fail;
11384 }
11385 {
11386 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11387 if (SWIG_arg_fail(3)) SWIG_fail;
11388 }
11389 {
11390 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11391 if (SWIG_arg_fail(4)) SWIG_fail;
11392 }
11393 {
11394 PyThreadState* __tstate = wxPyBeginAllowThreads();
11395 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11396
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 {
11401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11402 }
11403 return resultobj;
11404 fail:
11405 return NULL;
11406 }
11407
11408
11409 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11410 PyObject *resultobj;
11411 wxImage *arg1 = (wxImage *) 0 ;
11412 wxImage *arg2 = 0 ;
11413 byte arg3 ;
11414 byte arg4 ;
11415 byte arg5 ;
11416 bool result;
11417 PyObject * obj0 = 0 ;
11418 PyObject * obj1 = 0 ;
11419 PyObject * obj2 = 0 ;
11420 PyObject * obj3 = 0 ;
11421 PyObject * obj4 = 0 ;
11422 char *kwnames[] = {
11423 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11424 };
11425
11426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11428 if (SWIG_arg_fail(1)) SWIG_fail;
11429 {
11430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11431 if (SWIG_arg_fail(2)) SWIG_fail;
11432 if (arg2 == NULL) {
11433 SWIG_null_ref("wxImage");
11434 }
11435 if (SWIG_arg_fail(2)) SWIG_fail;
11436 }
11437 {
11438 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11439 if (SWIG_arg_fail(3)) SWIG_fail;
11440 }
11441 {
11442 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11443 if (SWIG_arg_fail(4)) SWIG_fail;
11444 }
11445 {
11446 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11447 if (SWIG_arg_fail(5)) SWIG_fail;
11448 }
11449 {
11450 PyThreadState* __tstate = wxPyBeginAllowThreads();
11451 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11452
11453 wxPyEndAllowThreads(__tstate);
11454 if (PyErr_Occurred()) SWIG_fail;
11455 }
11456 {
11457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11458 }
11459 return resultobj;
11460 fail:
11461 return NULL;
11462 }
11463
11464
11465 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11466 PyObject *resultobj;
11467 wxString *arg1 = 0 ;
11468 bool result;
11469 bool temp1 = false ;
11470 PyObject * obj0 = 0 ;
11471 char *kwnames[] = {
11472 (char *) "name", NULL
11473 };
11474
11475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11476 {
11477 arg1 = wxString_in_helper(obj0);
11478 if (arg1 == NULL) SWIG_fail;
11479 temp1 = true;
11480 }
11481 {
11482 PyThreadState* __tstate = wxPyBeginAllowThreads();
11483 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11484
11485 wxPyEndAllowThreads(__tstate);
11486 if (PyErr_Occurred()) SWIG_fail;
11487 }
11488 {
11489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11490 }
11491 {
11492 if (temp1)
11493 delete arg1;
11494 }
11495 return resultobj;
11496 fail:
11497 {
11498 if (temp1)
11499 delete arg1;
11500 }
11501 return NULL;
11502 }
11503
11504
11505 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11506 PyObject *resultobj;
11507 wxString *arg1 = 0 ;
11508 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11509 int result;
11510 bool temp1 = false ;
11511 PyObject * obj0 = 0 ;
11512 PyObject * obj1 = 0 ;
11513 char *kwnames[] = {
11514 (char *) "name",(char *) "type", NULL
11515 };
11516
11517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11518 {
11519 arg1 = wxString_in_helper(obj0);
11520 if (arg1 == NULL) SWIG_fail;
11521 temp1 = true;
11522 }
11523 if (obj1) {
11524 {
11525 arg2 = (long)(SWIG_As_long(obj1));
11526 if (SWIG_arg_fail(2)) SWIG_fail;
11527 }
11528 }
11529 {
11530 PyThreadState* __tstate = wxPyBeginAllowThreads();
11531 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11532
11533 wxPyEndAllowThreads(__tstate);
11534 if (PyErr_Occurred()) SWIG_fail;
11535 }
11536 {
11537 resultobj = SWIG_From_int((int)(result));
11538 }
11539 {
11540 if (temp1)
11541 delete arg1;
11542 }
11543 return resultobj;
11544 fail:
11545 {
11546 if (temp1)
11547 delete arg1;
11548 }
11549 return NULL;
11550 }
11551
11552
11553 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11554 PyObject *resultobj;
11555 wxImage *arg1 = (wxImage *) 0 ;
11556 wxString *arg2 = 0 ;
11557 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11558 int arg4 = (int) -1 ;
11559 bool result;
11560 bool temp2 = false ;
11561 PyObject * obj0 = 0 ;
11562 PyObject * obj1 = 0 ;
11563 PyObject * obj2 = 0 ;
11564 PyObject * obj3 = 0 ;
11565 char *kwnames[] = {
11566 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11567 };
11568
11569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11571 if (SWIG_arg_fail(1)) SWIG_fail;
11572 {
11573 arg2 = wxString_in_helper(obj1);
11574 if (arg2 == NULL) SWIG_fail;
11575 temp2 = true;
11576 }
11577 if (obj2) {
11578 {
11579 arg3 = (long)(SWIG_As_long(obj2));
11580 if (SWIG_arg_fail(3)) SWIG_fail;
11581 }
11582 }
11583 if (obj3) {
11584 {
11585 arg4 = (int)(SWIG_As_int(obj3));
11586 if (SWIG_arg_fail(4)) SWIG_fail;
11587 }
11588 }
11589 {
11590 PyThreadState* __tstate = wxPyBeginAllowThreads();
11591 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11592
11593 wxPyEndAllowThreads(__tstate);
11594 if (PyErr_Occurred()) SWIG_fail;
11595 }
11596 {
11597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11598 }
11599 {
11600 if (temp2)
11601 delete arg2;
11602 }
11603 return resultobj;
11604 fail:
11605 {
11606 if (temp2)
11607 delete arg2;
11608 }
11609 return NULL;
11610 }
11611
11612
11613 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11614 PyObject *resultobj;
11615 wxImage *arg1 = (wxImage *) 0 ;
11616 wxString *arg2 = 0 ;
11617 wxString *arg3 = 0 ;
11618 int arg4 = (int) -1 ;
11619 bool result;
11620 bool temp2 = false ;
11621 bool temp3 = false ;
11622 PyObject * obj0 = 0 ;
11623 PyObject * obj1 = 0 ;
11624 PyObject * obj2 = 0 ;
11625 PyObject * obj3 = 0 ;
11626 char *kwnames[] = {
11627 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11628 };
11629
11630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11632 if (SWIG_arg_fail(1)) SWIG_fail;
11633 {
11634 arg2 = wxString_in_helper(obj1);
11635 if (arg2 == NULL) SWIG_fail;
11636 temp2 = true;
11637 }
11638 {
11639 arg3 = wxString_in_helper(obj2);
11640 if (arg3 == NULL) SWIG_fail;
11641 temp3 = true;
11642 }
11643 if (obj3) {
11644 {
11645 arg4 = (int)(SWIG_As_int(obj3));
11646 if (SWIG_arg_fail(4)) SWIG_fail;
11647 }
11648 }
11649 {
11650 PyThreadState* __tstate = wxPyBeginAllowThreads();
11651 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11652
11653 wxPyEndAllowThreads(__tstate);
11654 if (PyErr_Occurred()) SWIG_fail;
11655 }
11656 {
11657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11658 }
11659 {
11660 if (temp2)
11661 delete arg2;
11662 }
11663 {
11664 if (temp3)
11665 delete arg3;
11666 }
11667 return resultobj;
11668 fail:
11669 {
11670 if (temp2)
11671 delete arg2;
11672 }
11673 {
11674 if (temp3)
11675 delete arg3;
11676 }
11677 return NULL;
11678 }
11679
11680
11681 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11682 PyObject *resultobj;
11683 wxImage *arg1 = (wxImage *) 0 ;
11684 wxString *arg2 = 0 ;
11685 int arg3 ;
11686 bool result;
11687 bool temp2 = false ;
11688 PyObject * obj0 = 0 ;
11689 PyObject * obj1 = 0 ;
11690 PyObject * obj2 = 0 ;
11691 char *kwnames[] = {
11692 (char *) "self",(char *) "name",(char *) "type", NULL
11693 };
11694
11695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11697 if (SWIG_arg_fail(1)) SWIG_fail;
11698 {
11699 arg2 = wxString_in_helper(obj1);
11700 if (arg2 == NULL) SWIG_fail;
11701 temp2 = true;
11702 }
11703 {
11704 arg3 = (int)(SWIG_As_int(obj2));
11705 if (SWIG_arg_fail(3)) SWIG_fail;
11706 }
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11710
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 {
11715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11716 }
11717 {
11718 if (temp2)
11719 delete arg2;
11720 }
11721 return resultobj;
11722 fail:
11723 {
11724 if (temp2)
11725 delete arg2;
11726 }
11727 return NULL;
11728 }
11729
11730
11731 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11732 PyObject *resultobj;
11733 wxImage *arg1 = (wxImage *) 0 ;
11734 wxString *arg2 = 0 ;
11735 wxString *arg3 = 0 ;
11736 bool result;
11737 bool temp2 = false ;
11738 bool temp3 = false ;
11739 PyObject * obj0 = 0 ;
11740 PyObject * obj1 = 0 ;
11741 PyObject * obj2 = 0 ;
11742 char *kwnames[] = {
11743 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11744 };
11745
11746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11748 if (SWIG_arg_fail(1)) SWIG_fail;
11749 {
11750 arg2 = wxString_in_helper(obj1);
11751 if (arg2 == NULL) SWIG_fail;
11752 temp2 = true;
11753 }
11754 {
11755 arg3 = wxString_in_helper(obj2);
11756 if (arg3 == NULL) SWIG_fail;
11757 temp3 = true;
11758 }
11759 {
11760 PyThreadState* __tstate = wxPyBeginAllowThreads();
11761 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11762
11763 wxPyEndAllowThreads(__tstate);
11764 if (PyErr_Occurred()) SWIG_fail;
11765 }
11766 {
11767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11768 }
11769 {
11770 if (temp2)
11771 delete arg2;
11772 }
11773 {
11774 if (temp3)
11775 delete arg3;
11776 }
11777 return resultobj;
11778 fail:
11779 {
11780 if (temp2)
11781 delete arg2;
11782 }
11783 {
11784 if (temp3)
11785 delete arg3;
11786 }
11787 return NULL;
11788 }
11789
11790
11791 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11792 PyObject *resultobj;
11793 wxInputStream *arg1 = 0 ;
11794 bool result;
11795 wxPyInputStream *temp1 ;
11796 bool created1 ;
11797 PyObject * obj0 = 0 ;
11798 char *kwnames[] = {
11799 (char *) "stream", NULL
11800 };
11801
11802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11803 {
11804 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11805 arg1 = temp1->m_wxis;
11806 created1 = false;
11807 } else {
11808 PyErr_Clear(); // clear the failure of the wxPyConvert above
11809 arg1 = wxPyCBInputStream_create(obj0, false);
11810 if (arg1 == NULL) {
11811 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11812 SWIG_fail;
11813 }
11814 created1 = true;
11815 }
11816 }
11817 {
11818 PyThreadState* __tstate = wxPyBeginAllowThreads();
11819 result = (bool)wxImage::CanRead(*arg1);
11820
11821 wxPyEndAllowThreads(__tstate);
11822 if (PyErr_Occurred()) SWIG_fail;
11823 }
11824 {
11825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11826 }
11827 {
11828 if (created1)
11829 delete arg1;
11830 }
11831 return resultobj;
11832 fail:
11833 {
11834 if (created1)
11835 delete arg1;
11836 }
11837 return NULL;
11838 }
11839
11840
11841 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11842 PyObject *resultobj;
11843 wxImage *arg1 = (wxImage *) 0 ;
11844 wxInputStream *arg2 = 0 ;
11845 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11846 int arg4 = (int) -1 ;
11847 bool result;
11848 wxPyInputStream *temp2 ;
11849 bool created2 ;
11850 PyObject * obj0 = 0 ;
11851 PyObject * obj1 = 0 ;
11852 PyObject * obj2 = 0 ;
11853 PyObject * obj3 = 0 ;
11854 char *kwnames[] = {
11855 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11856 };
11857
11858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11860 if (SWIG_arg_fail(1)) SWIG_fail;
11861 {
11862 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11863 arg2 = temp2->m_wxis;
11864 created2 = false;
11865 } else {
11866 PyErr_Clear(); // clear the failure of the wxPyConvert above
11867 arg2 = wxPyCBInputStream_create(obj1, false);
11868 if (arg2 == NULL) {
11869 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11870 SWIG_fail;
11871 }
11872 created2 = true;
11873 }
11874 }
11875 if (obj2) {
11876 {
11877 arg3 = (long)(SWIG_As_long(obj2));
11878 if (SWIG_arg_fail(3)) SWIG_fail;
11879 }
11880 }
11881 if (obj3) {
11882 {
11883 arg4 = (int)(SWIG_As_int(obj3));
11884 if (SWIG_arg_fail(4)) SWIG_fail;
11885 }
11886 }
11887 {
11888 PyThreadState* __tstate = wxPyBeginAllowThreads();
11889 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11890
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 {
11895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11896 }
11897 {
11898 if (created2)
11899 delete arg2;
11900 }
11901 return resultobj;
11902 fail:
11903 {
11904 if (created2)
11905 delete arg2;
11906 }
11907 return NULL;
11908 }
11909
11910
11911 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11912 PyObject *resultobj;
11913 wxImage *arg1 = (wxImage *) 0 ;
11914 wxInputStream *arg2 = 0 ;
11915 wxString *arg3 = 0 ;
11916 int arg4 = (int) -1 ;
11917 bool result;
11918 wxPyInputStream *temp2 ;
11919 bool created2 ;
11920 bool temp3 = false ;
11921 PyObject * obj0 = 0 ;
11922 PyObject * obj1 = 0 ;
11923 PyObject * obj2 = 0 ;
11924 PyObject * obj3 = 0 ;
11925 char *kwnames[] = {
11926 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11927 };
11928
11929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11931 if (SWIG_arg_fail(1)) SWIG_fail;
11932 {
11933 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11934 arg2 = temp2->m_wxis;
11935 created2 = false;
11936 } else {
11937 PyErr_Clear(); // clear the failure of the wxPyConvert above
11938 arg2 = wxPyCBInputStream_create(obj1, false);
11939 if (arg2 == NULL) {
11940 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11941 SWIG_fail;
11942 }
11943 created2 = true;
11944 }
11945 }
11946 {
11947 arg3 = wxString_in_helper(obj2);
11948 if (arg3 == NULL) SWIG_fail;
11949 temp3 = true;
11950 }
11951 if (obj3) {
11952 {
11953 arg4 = (int)(SWIG_As_int(obj3));
11954 if (SWIG_arg_fail(4)) SWIG_fail;
11955 }
11956 }
11957 {
11958 PyThreadState* __tstate = wxPyBeginAllowThreads();
11959 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11960
11961 wxPyEndAllowThreads(__tstate);
11962 if (PyErr_Occurred()) SWIG_fail;
11963 }
11964 {
11965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11966 }
11967 {
11968 if (created2)
11969 delete arg2;
11970 }
11971 {
11972 if (temp3)
11973 delete arg3;
11974 }
11975 return resultobj;
11976 fail:
11977 {
11978 if (created2)
11979 delete arg2;
11980 }
11981 {
11982 if (temp3)
11983 delete arg3;
11984 }
11985 return NULL;
11986 }
11987
11988
11989 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11990 PyObject *resultobj;
11991 wxImage *arg1 = (wxImage *) 0 ;
11992 bool result;
11993 PyObject * obj0 = 0 ;
11994 char *kwnames[] = {
11995 (char *) "self", NULL
11996 };
11997
11998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12000 if (SWIG_arg_fail(1)) SWIG_fail;
12001 {
12002 PyThreadState* __tstate = wxPyBeginAllowThreads();
12003 result = (bool)(arg1)->Ok();
12004
12005 wxPyEndAllowThreads(__tstate);
12006 if (PyErr_Occurred()) SWIG_fail;
12007 }
12008 {
12009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12010 }
12011 return resultobj;
12012 fail:
12013 return NULL;
12014 }
12015
12016
12017 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj;
12019 wxImage *arg1 = (wxImage *) 0 ;
12020 int result;
12021 PyObject * obj0 = 0 ;
12022 char *kwnames[] = {
12023 (char *) "self", NULL
12024 };
12025
12026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12028 if (SWIG_arg_fail(1)) SWIG_fail;
12029 {
12030 PyThreadState* __tstate = wxPyBeginAllowThreads();
12031 result = (int)(arg1)->GetWidth();
12032
12033 wxPyEndAllowThreads(__tstate);
12034 if (PyErr_Occurred()) SWIG_fail;
12035 }
12036 {
12037 resultobj = SWIG_From_int((int)(result));
12038 }
12039 return resultobj;
12040 fail:
12041 return NULL;
12042 }
12043
12044
12045 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12046 PyObject *resultobj;
12047 wxImage *arg1 = (wxImage *) 0 ;
12048 int result;
12049 PyObject * obj0 = 0 ;
12050 char *kwnames[] = {
12051 (char *) "self", NULL
12052 };
12053
12054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12056 if (SWIG_arg_fail(1)) SWIG_fail;
12057 {
12058 PyThreadState* __tstate = wxPyBeginAllowThreads();
12059 result = (int)(arg1)->GetHeight();
12060
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 {
12065 resultobj = SWIG_From_int((int)(result));
12066 }
12067 return resultobj;
12068 fail:
12069 return NULL;
12070 }
12071
12072
12073 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12074 PyObject *resultobj;
12075 wxImage *arg1 = (wxImage *) 0 ;
12076 wxSize result;
12077 PyObject * obj0 = 0 ;
12078 char *kwnames[] = {
12079 (char *) "self", NULL
12080 };
12081
12082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12084 if (SWIG_arg_fail(1)) SWIG_fail;
12085 {
12086 PyThreadState* __tstate = wxPyBeginAllowThreads();
12087 result = wxImage_GetSize(arg1);
12088
12089 wxPyEndAllowThreads(__tstate);
12090 if (PyErr_Occurred()) SWIG_fail;
12091 }
12092 {
12093 wxSize * resultptr;
12094 resultptr = new wxSize((wxSize &)(result));
12095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12096 }
12097 return resultobj;
12098 fail:
12099 return NULL;
12100 }
12101
12102
12103 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12104 PyObject *resultobj;
12105 wxImage *arg1 = (wxImage *) 0 ;
12106 wxRect *arg2 = 0 ;
12107 SwigValueWrapper<wxImage > result;
12108 wxRect temp2 ;
12109 PyObject * obj0 = 0 ;
12110 PyObject * obj1 = 0 ;
12111 char *kwnames[] = {
12112 (char *) "self",(char *) "rect", NULL
12113 };
12114
12115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) 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 {
12119 arg2 = &temp2;
12120 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12121 }
12122 {
12123 PyThreadState* __tstate = wxPyBeginAllowThreads();
12124 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12125
12126 wxPyEndAllowThreads(__tstate);
12127 if (PyErr_Occurred()) SWIG_fail;
12128 }
12129 {
12130 wxImage * resultptr;
12131 resultptr = new wxImage((wxImage &)(result));
12132 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12133 }
12134 return resultobj;
12135 fail:
12136 return NULL;
12137 }
12138
12139
12140 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12141 PyObject *resultobj;
12142 wxImage *arg1 = (wxImage *) 0 ;
12143 SwigValueWrapper<wxImage > result;
12144 PyObject * obj0 = 0 ;
12145 char *kwnames[] = {
12146 (char *) "self", NULL
12147 };
12148
12149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12151 if (SWIG_arg_fail(1)) SWIG_fail;
12152 {
12153 PyThreadState* __tstate = wxPyBeginAllowThreads();
12154 result = (arg1)->Copy();
12155
12156 wxPyEndAllowThreads(__tstate);
12157 if (PyErr_Occurred()) SWIG_fail;
12158 }
12159 {
12160 wxImage * resultptr;
12161 resultptr = new wxImage((wxImage &)(result));
12162 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12163 }
12164 return resultobj;
12165 fail:
12166 return NULL;
12167 }
12168
12169
12170 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12171 PyObject *resultobj;
12172 wxImage *arg1 = (wxImage *) 0 ;
12173 wxImage *arg2 = 0 ;
12174 int arg3 ;
12175 int arg4 ;
12176 PyObject * obj0 = 0 ;
12177 PyObject * obj1 = 0 ;
12178 PyObject * obj2 = 0 ;
12179 PyObject * obj3 = 0 ;
12180 char *kwnames[] = {
12181 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12182 };
12183
12184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12186 if (SWIG_arg_fail(1)) SWIG_fail;
12187 {
12188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12189 if (SWIG_arg_fail(2)) SWIG_fail;
12190 if (arg2 == NULL) {
12191 SWIG_null_ref("wxImage");
12192 }
12193 if (SWIG_arg_fail(2)) SWIG_fail;
12194 }
12195 {
12196 arg3 = (int)(SWIG_As_int(obj2));
12197 if (SWIG_arg_fail(3)) SWIG_fail;
12198 }
12199 {
12200 arg4 = (int)(SWIG_As_int(obj3));
12201 if (SWIG_arg_fail(4)) SWIG_fail;
12202 }
12203 {
12204 PyThreadState* __tstate = wxPyBeginAllowThreads();
12205 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12206
12207 wxPyEndAllowThreads(__tstate);
12208 if (PyErr_Occurred()) SWIG_fail;
12209 }
12210 Py_INCREF(Py_None); resultobj = Py_None;
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12218 PyObject *resultobj;
12219 wxImage *arg1 = (wxImage *) 0 ;
12220 PyObject *result;
12221 PyObject * obj0 = 0 ;
12222 char *kwnames[] = {
12223 (char *) "self", NULL
12224 };
12225
12226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12228 if (SWIG_arg_fail(1)) SWIG_fail;
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 result = (PyObject *)wxImage_GetData(arg1);
12232
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 resultobj = result;
12237 return resultobj;
12238 fail:
12239 return NULL;
12240 }
12241
12242
12243 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12244 PyObject *resultobj;
12245 wxImage *arg1 = (wxImage *) 0 ;
12246 PyObject *arg2 = (PyObject *) 0 ;
12247 PyObject * obj0 = 0 ;
12248 PyObject * obj1 = 0 ;
12249 char *kwnames[] = {
12250 (char *) "self",(char *) "data", NULL
12251 };
12252
12253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12255 if (SWIG_arg_fail(1)) SWIG_fail;
12256 arg2 = obj1;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 wxImage_SetData(arg1,arg2);
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 Py_INCREF(Py_None); resultobj = Py_None;
12265 return resultobj;
12266 fail:
12267 return NULL;
12268 }
12269
12270
12271 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12272 PyObject *resultobj;
12273 wxImage *arg1 = (wxImage *) 0 ;
12274 PyObject *result;
12275 PyObject * obj0 = 0 ;
12276 char *kwnames[] = {
12277 (char *) "self", NULL
12278 };
12279
12280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12282 if (SWIG_arg_fail(1)) SWIG_fail;
12283 {
12284 PyThreadState* __tstate = wxPyBeginAllowThreads();
12285 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12286
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = result;
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12298 PyObject *resultobj;
12299 wxImage *arg1 = (wxImage *) 0 ;
12300 PyObject *arg2 = (PyObject *) 0 ;
12301 PyObject * obj0 = 0 ;
12302 PyObject * obj1 = 0 ;
12303 char *kwnames[] = {
12304 (char *) "self",(char *) "data", NULL
12305 };
12306
12307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12309 if (SWIG_arg_fail(1)) SWIG_fail;
12310 arg2 = obj1;
12311 {
12312 PyThreadState* __tstate = wxPyBeginAllowThreads();
12313 wxImage_SetDataBuffer(arg1,arg2);
12314
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 Py_INCREF(Py_None); resultobj = Py_None;
12319 return resultobj;
12320 fail:
12321 return NULL;
12322 }
12323
12324
12325 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12326 PyObject *resultobj;
12327 wxImage *arg1 = (wxImage *) 0 ;
12328 PyObject *result;
12329 PyObject * obj0 = 0 ;
12330 char *kwnames[] = {
12331 (char *) "self", NULL
12332 };
12333
12334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12336 if (SWIG_arg_fail(1)) SWIG_fail;
12337 {
12338 PyThreadState* __tstate = wxPyBeginAllowThreads();
12339 result = (PyObject *)wxImage_GetAlphaData(arg1);
12340
12341 wxPyEndAllowThreads(__tstate);
12342 if (PyErr_Occurred()) SWIG_fail;
12343 }
12344 resultobj = result;
12345 return resultobj;
12346 fail:
12347 return NULL;
12348 }
12349
12350
12351 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12352 PyObject *resultobj;
12353 wxImage *arg1 = (wxImage *) 0 ;
12354 PyObject *arg2 = (PyObject *) 0 ;
12355 PyObject * obj0 = 0 ;
12356 PyObject * obj1 = 0 ;
12357 char *kwnames[] = {
12358 (char *) "self",(char *) "data", NULL
12359 };
12360
12361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12363 if (SWIG_arg_fail(1)) SWIG_fail;
12364 arg2 = obj1;
12365 {
12366 PyThreadState* __tstate = wxPyBeginAllowThreads();
12367 wxImage_SetAlphaData(arg1,arg2);
12368
12369 wxPyEndAllowThreads(__tstate);
12370 if (PyErr_Occurred()) SWIG_fail;
12371 }
12372 Py_INCREF(Py_None); resultobj = Py_None;
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj;
12381 wxImage *arg1 = (wxImage *) 0 ;
12382 PyObject *result;
12383 PyObject * obj0 = 0 ;
12384 char *kwnames[] = {
12385 (char *) "self", NULL
12386 };
12387
12388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12390 if (SWIG_arg_fail(1)) SWIG_fail;
12391 {
12392 PyThreadState* __tstate = wxPyBeginAllowThreads();
12393 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12394
12395 wxPyEndAllowThreads(__tstate);
12396 if (PyErr_Occurred()) SWIG_fail;
12397 }
12398 resultobj = result;
12399 return resultobj;
12400 fail:
12401 return NULL;
12402 }
12403
12404
12405 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12406 PyObject *resultobj;
12407 wxImage *arg1 = (wxImage *) 0 ;
12408 PyObject *arg2 = (PyObject *) 0 ;
12409 PyObject * obj0 = 0 ;
12410 PyObject * obj1 = 0 ;
12411 char *kwnames[] = {
12412 (char *) "self",(char *) "data", NULL
12413 };
12414
12415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12417 if (SWIG_arg_fail(1)) SWIG_fail;
12418 arg2 = obj1;
12419 {
12420 PyThreadState* __tstate = wxPyBeginAllowThreads();
12421 wxImage_SetAlphaBuffer(arg1,arg2);
12422
12423 wxPyEndAllowThreads(__tstate);
12424 if (PyErr_Occurred()) SWIG_fail;
12425 }
12426 Py_INCREF(Py_None); resultobj = Py_None;
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj;
12435 wxImage *arg1 = (wxImage *) 0 ;
12436 unsigned char arg2 ;
12437 unsigned char arg3 ;
12438 unsigned char arg4 ;
12439 PyObject * obj0 = 0 ;
12440 PyObject * obj1 = 0 ;
12441 PyObject * obj2 = 0 ;
12442 PyObject * obj3 = 0 ;
12443 char *kwnames[] = {
12444 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12445 };
12446
12447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12449 if (SWIG_arg_fail(1)) SWIG_fail;
12450 {
12451 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12452 if (SWIG_arg_fail(2)) SWIG_fail;
12453 }
12454 {
12455 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12456 if (SWIG_arg_fail(3)) SWIG_fail;
12457 }
12458 {
12459 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12460 if (SWIG_arg_fail(4)) SWIG_fail;
12461 }
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 (arg1)->SetMaskColour(arg2,arg3,arg4);
12465
12466 wxPyEndAllowThreads(__tstate);
12467 if (PyErr_Occurred()) SWIG_fail;
12468 }
12469 Py_INCREF(Py_None); resultobj = Py_None;
12470 return resultobj;
12471 fail:
12472 return NULL;
12473 }
12474
12475
12476 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12477 PyObject *resultobj;
12478 wxImage *arg1 = (wxImage *) 0 ;
12479 unsigned char result;
12480 PyObject * obj0 = 0 ;
12481 char *kwnames[] = {
12482 (char *) "self", NULL
12483 };
12484
12485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12487 if (SWIG_arg_fail(1)) SWIG_fail;
12488 {
12489 PyThreadState* __tstate = wxPyBeginAllowThreads();
12490 result = (unsigned char)(arg1)->GetMaskRed();
12491
12492 wxPyEndAllowThreads(__tstate);
12493 if (PyErr_Occurred()) SWIG_fail;
12494 }
12495 {
12496 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12497 }
12498 return resultobj;
12499 fail:
12500 return NULL;
12501 }
12502
12503
12504 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12505 PyObject *resultobj;
12506 wxImage *arg1 = (wxImage *) 0 ;
12507 unsigned char result;
12508 PyObject * obj0 = 0 ;
12509 char *kwnames[] = {
12510 (char *) "self", NULL
12511 };
12512
12513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12515 if (SWIG_arg_fail(1)) SWIG_fail;
12516 {
12517 PyThreadState* __tstate = wxPyBeginAllowThreads();
12518 result = (unsigned char)(arg1)->GetMaskGreen();
12519
12520 wxPyEndAllowThreads(__tstate);
12521 if (PyErr_Occurred()) SWIG_fail;
12522 }
12523 {
12524 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12525 }
12526 return resultobj;
12527 fail:
12528 return NULL;
12529 }
12530
12531
12532 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12533 PyObject *resultobj;
12534 wxImage *arg1 = (wxImage *) 0 ;
12535 unsigned char result;
12536 PyObject * obj0 = 0 ;
12537 char *kwnames[] = {
12538 (char *) "self", NULL
12539 };
12540
12541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12543 if (SWIG_arg_fail(1)) SWIG_fail;
12544 {
12545 PyThreadState* __tstate = wxPyBeginAllowThreads();
12546 result = (unsigned char)(arg1)->GetMaskBlue();
12547
12548 wxPyEndAllowThreads(__tstate);
12549 if (PyErr_Occurred()) SWIG_fail;
12550 }
12551 {
12552 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12553 }
12554 return resultobj;
12555 fail:
12556 return NULL;
12557 }
12558
12559
12560 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12561 PyObject *resultobj;
12562 wxImage *arg1 = (wxImage *) 0 ;
12563 bool arg2 = (bool) true ;
12564 PyObject * obj0 = 0 ;
12565 PyObject * obj1 = 0 ;
12566 char *kwnames[] = {
12567 (char *) "self",(char *) "mask", NULL
12568 };
12569
12570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12572 if (SWIG_arg_fail(1)) SWIG_fail;
12573 if (obj1) {
12574 {
12575 arg2 = (bool)(SWIG_As_bool(obj1));
12576 if (SWIG_arg_fail(2)) SWIG_fail;
12577 }
12578 }
12579 {
12580 PyThreadState* __tstate = wxPyBeginAllowThreads();
12581 (arg1)->SetMask(arg2);
12582
12583 wxPyEndAllowThreads(__tstate);
12584 if (PyErr_Occurred()) SWIG_fail;
12585 }
12586 Py_INCREF(Py_None); resultobj = Py_None;
12587 return resultobj;
12588 fail:
12589 return NULL;
12590 }
12591
12592
12593 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12594 PyObject *resultobj;
12595 wxImage *arg1 = (wxImage *) 0 ;
12596 bool result;
12597 PyObject * obj0 = 0 ;
12598 char *kwnames[] = {
12599 (char *) "self", NULL
12600 };
12601
12602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12604 if (SWIG_arg_fail(1)) SWIG_fail;
12605 {
12606 PyThreadState* __tstate = wxPyBeginAllowThreads();
12607 result = (bool)(arg1)->HasMask();
12608
12609 wxPyEndAllowThreads(__tstate);
12610 if (PyErr_Occurred()) SWIG_fail;
12611 }
12612 {
12613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12614 }
12615 return resultobj;
12616 fail:
12617 return NULL;
12618 }
12619
12620
12621 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12622 PyObject *resultobj;
12623 wxImage *arg1 = (wxImage *) 0 ;
12624 double arg2 ;
12625 wxPoint *arg3 = 0 ;
12626 bool arg4 = (bool) true ;
12627 wxPoint *arg5 = (wxPoint *) NULL ;
12628 SwigValueWrapper<wxImage > result;
12629 wxPoint temp3 ;
12630 PyObject * obj0 = 0 ;
12631 PyObject * obj1 = 0 ;
12632 PyObject * obj2 = 0 ;
12633 PyObject * obj3 = 0 ;
12634 PyObject * obj4 = 0 ;
12635 char *kwnames[] = {
12636 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12637 };
12638
12639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12641 if (SWIG_arg_fail(1)) SWIG_fail;
12642 {
12643 arg2 = (double)(SWIG_As_double(obj1));
12644 if (SWIG_arg_fail(2)) SWIG_fail;
12645 }
12646 {
12647 arg3 = &temp3;
12648 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12649 }
12650 if (obj3) {
12651 {
12652 arg4 = (bool)(SWIG_As_bool(obj3));
12653 if (SWIG_arg_fail(4)) SWIG_fail;
12654 }
12655 }
12656 if (obj4) {
12657 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12658 if (SWIG_arg_fail(5)) SWIG_fail;
12659 }
12660 {
12661 PyThreadState* __tstate = wxPyBeginAllowThreads();
12662 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12663
12664 wxPyEndAllowThreads(__tstate);
12665 if (PyErr_Occurred()) SWIG_fail;
12666 }
12667 {
12668 wxImage * resultptr;
12669 resultptr = new wxImage((wxImage &)(result));
12670 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12671 }
12672 return resultobj;
12673 fail:
12674 return NULL;
12675 }
12676
12677
12678 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12679 PyObject *resultobj;
12680 wxImage *arg1 = (wxImage *) 0 ;
12681 bool arg2 = (bool) true ;
12682 SwigValueWrapper<wxImage > result;
12683 PyObject * obj0 = 0 ;
12684 PyObject * obj1 = 0 ;
12685 char *kwnames[] = {
12686 (char *) "self",(char *) "clockwise", NULL
12687 };
12688
12689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12691 if (SWIG_arg_fail(1)) SWIG_fail;
12692 if (obj1) {
12693 {
12694 arg2 = (bool)(SWIG_As_bool(obj1));
12695 if (SWIG_arg_fail(2)) SWIG_fail;
12696 }
12697 }
12698 {
12699 PyThreadState* __tstate = wxPyBeginAllowThreads();
12700 result = (arg1)->Rotate90(arg2);
12701
12702 wxPyEndAllowThreads(__tstate);
12703 if (PyErr_Occurred()) SWIG_fail;
12704 }
12705 {
12706 wxImage * resultptr;
12707 resultptr = new wxImage((wxImage &)(result));
12708 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12709 }
12710 return resultobj;
12711 fail:
12712 return NULL;
12713 }
12714
12715
12716 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12717 PyObject *resultobj;
12718 wxImage *arg1 = (wxImage *) 0 ;
12719 bool arg2 = (bool) true ;
12720 SwigValueWrapper<wxImage > result;
12721 PyObject * obj0 = 0 ;
12722 PyObject * obj1 = 0 ;
12723 char *kwnames[] = {
12724 (char *) "self",(char *) "horizontally", NULL
12725 };
12726
12727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12729 if (SWIG_arg_fail(1)) SWIG_fail;
12730 if (obj1) {
12731 {
12732 arg2 = (bool)(SWIG_As_bool(obj1));
12733 if (SWIG_arg_fail(2)) SWIG_fail;
12734 }
12735 }
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 result = (arg1)->Mirror(arg2);
12739
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 {
12744 wxImage * resultptr;
12745 resultptr = new wxImage((wxImage &)(result));
12746 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12747 }
12748 return resultobj;
12749 fail:
12750 return NULL;
12751 }
12752
12753
12754 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12755 PyObject *resultobj;
12756 wxImage *arg1 = (wxImage *) 0 ;
12757 unsigned char arg2 ;
12758 unsigned char arg3 ;
12759 unsigned char arg4 ;
12760 unsigned char arg5 ;
12761 unsigned char arg6 ;
12762 unsigned char arg7 ;
12763 PyObject * obj0 = 0 ;
12764 PyObject * obj1 = 0 ;
12765 PyObject * obj2 = 0 ;
12766 PyObject * obj3 = 0 ;
12767 PyObject * obj4 = 0 ;
12768 PyObject * obj5 = 0 ;
12769 PyObject * obj6 = 0 ;
12770 char *kwnames[] = {
12771 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12772 };
12773
12774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12776 if (SWIG_arg_fail(1)) SWIG_fail;
12777 {
12778 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12779 if (SWIG_arg_fail(2)) SWIG_fail;
12780 }
12781 {
12782 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12783 if (SWIG_arg_fail(3)) SWIG_fail;
12784 }
12785 {
12786 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12787 if (SWIG_arg_fail(4)) SWIG_fail;
12788 }
12789 {
12790 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12791 if (SWIG_arg_fail(5)) SWIG_fail;
12792 }
12793 {
12794 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12795 if (SWIG_arg_fail(6)) SWIG_fail;
12796 }
12797 {
12798 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12799 if (SWIG_arg_fail(7)) SWIG_fail;
12800 }
12801 {
12802 PyThreadState* __tstate = wxPyBeginAllowThreads();
12803 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12804
12805 wxPyEndAllowThreads(__tstate);
12806 if (PyErr_Occurred()) SWIG_fail;
12807 }
12808 Py_INCREF(Py_None); resultobj = Py_None;
12809 return resultobj;
12810 fail:
12811 return NULL;
12812 }
12813
12814
12815 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12816 PyObject *resultobj;
12817 wxImage *arg1 = (wxImage *) 0 ;
12818 unsigned char arg2 ;
12819 unsigned char arg3 ;
12820 unsigned char arg4 ;
12821 SwigValueWrapper<wxImage > result;
12822 PyObject * obj0 = 0 ;
12823 PyObject * obj1 = 0 ;
12824 PyObject * obj2 = 0 ;
12825 PyObject * obj3 = 0 ;
12826 char *kwnames[] = {
12827 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12828 };
12829
12830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12832 if (SWIG_arg_fail(1)) SWIG_fail;
12833 {
12834 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12835 if (SWIG_arg_fail(2)) SWIG_fail;
12836 }
12837 {
12838 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12839 if (SWIG_arg_fail(3)) SWIG_fail;
12840 }
12841 {
12842 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12843 if (SWIG_arg_fail(4)) SWIG_fail;
12844 }
12845 {
12846 PyThreadState* __tstate = wxPyBeginAllowThreads();
12847 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12848
12849 wxPyEndAllowThreads(__tstate);
12850 if (PyErr_Occurred()) SWIG_fail;
12851 }
12852 {
12853 wxImage * resultptr;
12854 resultptr = new wxImage((wxImage &)(result));
12855 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12856 }
12857 return resultobj;
12858 fail:
12859 return NULL;
12860 }
12861
12862
12863 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12864 PyObject *resultobj;
12865 wxImage *arg1 = (wxImage *) 0 ;
12866 wxString *arg2 = 0 ;
12867 wxString *arg3 = 0 ;
12868 bool temp2 = false ;
12869 bool temp3 = false ;
12870 PyObject * obj0 = 0 ;
12871 PyObject * obj1 = 0 ;
12872 PyObject * obj2 = 0 ;
12873 char *kwnames[] = {
12874 (char *) "self",(char *) "name",(char *) "value", NULL
12875 };
12876
12877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12879 if (SWIG_arg_fail(1)) SWIG_fail;
12880 {
12881 arg2 = wxString_in_helper(obj1);
12882 if (arg2 == NULL) SWIG_fail;
12883 temp2 = true;
12884 }
12885 {
12886 arg3 = wxString_in_helper(obj2);
12887 if (arg3 == NULL) SWIG_fail;
12888 temp3 = true;
12889 }
12890 {
12891 PyThreadState* __tstate = wxPyBeginAllowThreads();
12892 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12893
12894 wxPyEndAllowThreads(__tstate);
12895 if (PyErr_Occurred()) SWIG_fail;
12896 }
12897 Py_INCREF(Py_None); resultobj = Py_None;
12898 {
12899 if (temp2)
12900 delete arg2;
12901 }
12902 {
12903 if (temp3)
12904 delete arg3;
12905 }
12906 return resultobj;
12907 fail:
12908 {
12909 if (temp2)
12910 delete arg2;
12911 }
12912 {
12913 if (temp3)
12914 delete arg3;
12915 }
12916 return NULL;
12917 }
12918
12919
12920 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12921 PyObject *resultobj;
12922 wxImage *arg1 = (wxImage *) 0 ;
12923 wxString *arg2 = 0 ;
12924 int arg3 ;
12925 bool temp2 = false ;
12926 PyObject * obj0 = 0 ;
12927 PyObject * obj1 = 0 ;
12928 PyObject * obj2 = 0 ;
12929 char *kwnames[] = {
12930 (char *) "self",(char *) "name",(char *) "value", NULL
12931 };
12932
12933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12935 if (SWIG_arg_fail(1)) SWIG_fail;
12936 {
12937 arg2 = wxString_in_helper(obj1);
12938 if (arg2 == NULL) SWIG_fail;
12939 temp2 = true;
12940 }
12941 {
12942 arg3 = (int)(SWIG_As_int(obj2));
12943 if (SWIG_arg_fail(3)) SWIG_fail;
12944 }
12945 {
12946 PyThreadState* __tstate = wxPyBeginAllowThreads();
12947 (arg1)->SetOption((wxString const &)*arg2,arg3);
12948
12949 wxPyEndAllowThreads(__tstate);
12950 if (PyErr_Occurred()) SWIG_fail;
12951 }
12952 Py_INCREF(Py_None); resultobj = Py_None;
12953 {
12954 if (temp2)
12955 delete arg2;
12956 }
12957 return resultobj;
12958 fail:
12959 {
12960 if (temp2)
12961 delete arg2;
12962 }
12963 return NULL;
12964 }
12965
12966
12967 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12968 PyObject *resultobj;
12969 wxImage *arg1 = (wxImage *) 0 ;
12970 wxString *arg2 = 0 ;
12971 wxString result;
12972 bool temp2 = false ;
12973 PyObject * obj0 = 0 ;
12974 PyObject * obj1 = 0 ;
12975 char *kwnames[] = {
12976 (char *) "self",(char *) "name", NULL
12977 };
12978
12979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12981 if (SWIG_arg_fail(1)) SWIG_fail;
12982 {
12983 arg2 = wxString_in_helper(obj1);
12984 if (arg2 == NULL) SWIG_fail;
12985 temp2 = true;
12986 }
12987 {
12988 PyThreadState* __tstate = wxPyBeginAllowThreads();
12989 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12990
12991 wxPyEndAllowThreads(__tstate);
12992 if (PyErr_Occurred()) SWIG_fail;
12993 }
12994 {
12995 #if wxUSE_UNICODE
12996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12997 #else
12998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12999 #endif
13000 }
13001 {
13002 if (temp2)
13003 delete arg2;
13004 }
13005 return resultobj;
13006 fail:
13007 {
13008 if (temp2)
13009 delete arg2;
13010 }
13011 return NULL;
13012 }
13013
13014
13015 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13016 PyObject *resultobj;
13017 wxImage *arg1 = (wxImage *) 0 ;
13018 wxString *arg2 = 0 ;
13019 int result;
13020 bool temp2 = false ;
13021 PyObject * obj0 = 0 ;
13022 PyObject * obj1 = 0 ;
13023 char *kwnames[] = {
13024 (char *) "self",(char *) "name", NULL
13025 };
13026
13027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13029 if (SWIG_arg_fail(1)) SWIG_fail;
13030 {
13031 arg2 = wxString_in_helper(obj1);
13032 if (arg2 == NULL) SWIG_fail;
13033 temp2 = true;
13034 }
13035 {
13036 PyThreadState* __tstate = wxPyBeginAllowThreads();
13037 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13038
13039 wxPyEndAllowThreads(__tstate);
13040 if (PyErr_Occurred()) SWIG_fail;
13041 }
13042 {
13043 resultobj = SWIG_From_int((int)(result));
13044 }
13045 {
13046 if (temp2)
13047 delete arg2;
13048 }
13049 return resultobj;
13050 fail:
13051 {
13052 if (temp2)
13053 delete arg2;
13054 }
13055 return NULL;
13056 }
13057
13058
13059 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13060 PyObject *resultobj;
13061 wxImage *arg1 = (wxImage *) 0 ;
13062 wxString *arg2 = 0 ;
13063 bool result;
13064 bool temp2 = false ;
13065 PyObject * obj0 = 0 ;
13066 PyObject * obj1 = 0 ;
13067 char *kwnames[] = {
13068 (char *) "self",(char *) "name", NULL
13069 };
13070
13071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13073 if (SWIG_arg_fail(1)) SWIG_fail;
13074 {
13075 arg2 = wxString_in_helper(obj1);
13076 if (arg2 == NULL) SWIG_fail;
13077 temp2 = true;
13078 }
13079 {
13080 PyThreadState* __tstate = wxPyBeginAllowThreads();
13081 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13082
13083 wxPyEndAllowThreads(__tstate);
13084 if (PyErr_Occurred()) SWIG_fail;
13085 }
13086 {
13087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13088 }
13089 {
13090 if (temp2)
13091 delete arg2;
13092 }
13093 return resultobj;
13094 fail:
13095 {
13096 if (temp2)
13097 delete arg2;
13098 }
13099 return NULL;
13100 }
13101
13102
13103 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13104 PyObject *resultobj;
13105 wxImage *arg1 = (wxImage *) 0 ;
13106 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13107 unsigned long result;
13108 PyObject * obj0 = 0 ;
13109 PyObject * obj1 = 0 ;
13110 char *kwnames[] = {
13111 (char *) "self",(char *) "stopafter", NULL
13112 };
13113
13114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13116 if (SWIG_arg_fail(1)) SWIG_fail;
13117 if (obj1) {
13118 {
13119 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13120 if (SWIG_arg_fail(2)) SWIG_fail;
13121 }
13122 }
13123 {
13124 PyThreadState* __tstate = wxPyBeginAllowThreads();
13125 result = (unsigned long)(arg1)->CountColours(arg2);
13126
13127 wxPyEndAllowThreads(__tstate);
13128 if (PyErr_Occurred()) SWIG_fail;
13129 }
13130 {
13131 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13132 }
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj;
13141 wxImage *arg1 = (wxImage *) 0 ;
13142 wxImageHistogram *arg2 = 0 ;
13143 unsigned long result;
13144 PyObject * obj0 = 0 ;
13145 PyObject * obj1 = 0 ;
13146 char *kwnames[] = {
13147 (char *) "self",(char *) "h", NULL
13148 };
13149
13150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13152 if (SWIG_arg_fail(1)) SWIG_fail;
13153 {
13154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13155 if (SWIG_arg_fail(2)) SWIG_fail;
13156 if (arg2 == NULL) {
13157 SWIG_null_ref("wxImageHistogram");
13158 }
13159 if (SWIG_arg_fail(2)) SWIG_fail;
13160 }
13161 {
13162 PyThreadState* __tstate = wxPyBeginAllowThreads();
13163 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13164
13165 wxPyEndAllowThreads(__tstate);
13166 if (PyErr_Occurred()) SWIG_fail;
13167 }
13168 {
13169 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13170 }
13171 return resultobj;
13172 fail:
13173 return NULL;
13174 }
13175
13176
13177 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13178 PyObject *resultobj;
13179 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13180 PyObject * obj0 = 0 ;
13181 char *kwnames[] = {
13182 (char *) "handler", NULL
13183 };
13184
13185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13187 if (SWIG_arg_fail(1)) SWIG_fail;
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 wxImage::AddHandler(arg1);
13191
13192 wxPyEndAllowThreads(__tstate);
13193 if (PyErr_Occurred()) SWIG_fail;
13194 }
13195 Py_INCREF(Py_None); resultobj = Py_None;
13196 return resultobj;
13197 fail:
13198 return NULL;
13199 }
13200
13201
13202 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13203 PyObject *resultobj;
13204 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13205 PyObject * obj0 = 0 ;
13206 char *kwnames[] = {
13207 (char *) "handler", NULL
13208 };
13209
13210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13212 if (SWIG_arg_fail(1)) SWIG_fail;
13213 {
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 wxImage::InsertHandler(arg1);
13216
13217 wxPyEndAllowThreads(__tstate);
13218 if (PyErr_Occurred()) SWIG_fail;
13219 }
13220 Py_INCREF(Py_None); resultobj = Py_None;
13221 return resultobj;
13222 fail:
13223 return NULL;
13224 }
13225
13226
13227 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13228 PyObject *resultobj;
13229 wxString *arg1 = 0 ;
13230 bool result;
13231 bool temp1 = false ;
13232 PyObject * obj0 = 0 ;
13233 char *kwnames[] = {
13234 (char *) "name", NULL
13235 };
13236
13237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13238 {
13239 arg1 = wxString_in_helper(obj0);
13240 if (arg1 == NULL) SWIG_fail;
13241 temp1 = true;
13242 }
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13246
13247 wxPyEndAllowThreads(__tstate);
13248 if (PyErr_Occurred()) SWIG_fail;
13249 }
13250 {
13251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13252 }
13253 {
13254 if (temp1)
13255 delete arg1;
13256 }
13257 return resultobj;
13258 fail:
13259 {
13260 if (temp1)
13261 delete arg1;
13262 }
13263 return NULL;
13264 }
13265
13266
13267 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13268 PyObject *resultobj;
13269 wxString result;
13270 char *kwnames[] = {
13271 NULL
13272 };
13273
13274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13275 {
13276 PyThreadState* __tstate = wxPyBeginAllowThreads();
13277 result = wxImage::GetImageExtWildcard();
13278
13279 wxPyEndAllowThreads(__tstate);
13280 if (PyErr_Occurred()) SWIG_fail;
13281 }
13282 {
13283 #if wxUSE_UNICODE
13284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13285 #else
13286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13287 #endif
13288 }
13289 return resultobj;
13290 fail:
13291 return NULL;
13292 }
13293
13294
13295 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13296 PyObject *resultobj;
13297 wxImage *arg1 = (wxImage *) 0 ;
13298 int arg2 = (int) -1 ;
13299 wxBitmap result;
13300 PyObject * obj0 = 0 ;
13301 PyObject * obj1 = 0 ;
13302 char *kwnames[] = {
13303 (char *) "self",(char *) "depth", NULL
13304 };
13305
13306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13308 if (SWIG_arg_fail(1)) SWIG_fail;
13309 if (obj1) {
13310 {
13311 arg2 = (int)(SWIG_As_int(obj1));
13312 if (SWIG_arg_fail(2)) SWIG_fail;
13313 }
13314 }
13315 {
13316 if (!wxPyCheckForApp()) SWIG_fail;
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 result = wxImage_ConvertToBitmap(arg1,arg2);
13319
13320 wxPyEndAllowThreads(__tstate);
13321 if (PyErr_Occurred()) SWIG_fail;
13322 }
13323 {
13324 wxBitmap * resultptr;
13325 resultptr = new wxBitmap((wxBitmap &)(result));
13326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13327 }
13328 return resultobj;
13329 fail:
13330 return NULL;
13331 }
13332
13333
13334 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13335 PyObject *resultobj;
13336 wxImage *arg1 = (wxImage *) 0 ;
13337 unsigned char arg2 ;
13338 unsigned char arg3 ;
13339 unsigned char arg4 ;
13340 wxBitmap result;
13341 PyObject * obj0 = 0 ;
13342 PyObject * obj1 = 0 ;
13343 PyObject * obj2 = 0 ;
13344 PyObject * obj3 = 0 ;
13345 char *kwnames[] = {
13346 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13347 };
13348
13349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13351 if (SWIG_arg_fail(1)) SWIG_fail;
13352 {
13353 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13354 if (SWIG_arg_fail(2)) SWIG_fail;
13355 }
13356 {
13357 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13358 if (SWIG_arg_fail(3)) SWIG_fail;
13359 }
13360 {
13361 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13362 if (SWIG_arg_fail(4)) SWIG_fail;
13363 }
13364 {
13365 if (!wxPyCheckForApp()) SWIG_fail;
13366 PyThreadState* __tstate = wxPyBeginAllowThreads();
13367 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13368
13369 wxPyEndAllowThreads(__tstate);
13370 if (PyErr_Occurred()) SWIG_fail;
13371 }
13372 {
13373 wxBitmap * resultptr;
13374 resultptr = new wxBitmap((wxBitmap &)(result));
13375 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13376 }
13377 return resultobj;
13378 fail:
13379 return NULL;
13380 }
13381
13382
13383 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13384 PyObject *obj;
13385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13386 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13387 Py_INCREF(obj);
13388 return Py_BuildValue((char *)"");
13389 }
13390 static int _wrap_NullImage_set(PyObject *) {
13391 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13392 return 1;
13393 }
13394
13395
13396 static PyObject *_wrap_NullImage_get(void) {
13397 PyObject *pyobj;
13398
13399 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13400 return pyobj;
13401 }
13402
13403
13404 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13405 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13406 return 1;
13407 }
13408
13409
13410 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13411 PyObject *pyobj;
13412
13413 {
13414 #if wxUSE_UNICODE
13415 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13416 #else
13417 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13418 #endif
13419 }
13420 return pyobj;
13421 }
13422
13423
13424 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13425 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13426 return 1;
13427 }
13428
13429
13430 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13431 PyObject *pyobj;
13432
13433 {
13434 #if wxUSE_UNICODE
13435 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13436 #else
13437 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13438 #endif
13439 }
13440 return pyobj;
13441 }
13442
13443
13444 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13445 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13446 return 1;
13447 }
13448
13449
13450 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13451 PyObject *pyobj;
13452
13453 {
13454 #if wxUSE_UNICODE
13455 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13456 #else
13457 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13458 #endif
13459 }
13460 return pyobj;
13461 }
13462
13463
13464 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13465 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13466 return 1;
13467 }
13468
13469
13470 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13471 PyObject *pyobj;
13472
13473 {
13474 #if wxUSE_UNICODE
13475 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13476 #else
13477 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13478 #endif
13479 }
13480 return pyobj;
13481 }
13482
13483
13484 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13485 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13486 return 1;
13487 }
13488
13489
13490 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13491 PyObject *pyobj;
13492
13493 {
13494 #if wxUSE_UNICODE
13495 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13496 #else
13497 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13498 #endif
13499 }
13500 return pyobj;
13501 }
13502
13503
13504 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13505 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13506 return 1;
13507 }
13508
13509
13510 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13511 PyObject *pyobj;
13512
13513 {
13514 #if wxUSE_UNICODE
13515 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13516 #else
13517 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13518 #endif
13519 }
13520 return pyobj;
13521 }
13522
13523
13524 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13525 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13526 return 1;
13527 }
13528
13529
13530 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13531 PyObject *pyobj;
13532
13533 {
13534 #if wxUSE_UNICODE
13535 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13536 #else
13537 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13538 #endif
13539 }
13540 return pyobj;
13541 }
13542
13543
13544 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13545 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13546 return 1;
13547 }
13548
13549
13550 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13551 PyObject *pyobj;
13552
13553 {
13554 #if wxUSE_UNICODE
13555 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13556 #else
13557 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13558 #endif
13559 }
13560 return pyobj;
13561 }
13562
13563
13564 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13565 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13566 return 1;
13567 }
13568
13569
13570 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13571 PyObject *pyobj;
13572
13573 {
13574 #if wxUSE_UNICODE
13575 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13576 #else
13577 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13578 #endif
13579 }
13580 return pyobj;
13581 }
13582
13583
13584 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13585 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13586 return 1;
13587 }
13588
13589
13590 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13591 PyObject *pyobj;
13592
13593 {
13594 #if wxUSE_UNICODE
13595 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13596 #else
13597 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13598 #endif
13599 }
13600 return pyobj;
13601 }
13602
13603
13604 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13605 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13606 return 1;
13607 }
13608
13609
13610 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13611 PyObject *pyobj;
13612
13613 {
13614 #if wxUSE_UNICODE
13615 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13616 #else
13617 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13618 #endif
13619 }
13620 return pyobj;
13621 }
13622
13623
13624 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13625 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13626 return 1;
13627 }
13628
13629
13630 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13631 PyObject *pyobj;
13632
13633 {
13634 #if wxUSE_UNICODE
13635 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13636 #else
13637 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13638 #endif
13639 }
13640 return pyobj;
13641 }
13642
13643
13644 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13645 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13646 return 1;
13647 }
13648
13649
13650 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13651 PyObject *pyobj;
13652
13653 {
13654 #if wxUSE_UNICODE
13655 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13656 #else
13657 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13658 #endif
13659 }
13660 return pyobj;
13661 }
13662
13663
13664 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
13665 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
13666 return 1;
13667 }
13668
13669
13670 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
13671 PyObject *pyobj;
13672
13673 {
13674 #if wxUSE_UNICODE
13675 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13676 #else
13677 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
13678 #endif
13679 }
13680 return pyobj;
13681 }
13682
13683
13684 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
13685 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
13686 return 1;
13687 }
13688
13689
13690 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
13691 PyObject *pyobj;
13692
13693 {
13694 #if wxUSE_UNICODE
13695 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13696 #else
13697 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
13698 #endif
13699 }
13700 return pyobj;
13701 }
13702
13703
13704 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13705 PyObject *resultobj;
13706 wxBMPHandler *result;
13707 char *kwnames[] = {
13708 NULL
13709 };
13710
13711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13712 {
13713 PyThreadState* __tstate = wxPyBeginAllowThreads();
13714 result = (wxBMPHandler *)new wxBMPHandler();
13715
13716 wxPyEndAllowThreads(__tstate);
13717 if (PyErr_Occurred()) SWIG_fail;
13718 }
13719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13720 return resultobj;
13721 fail:
13722 return NULL;
13723 }
13724
13725
13726 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13727 PyObject *obj;
13728 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13729 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13730 Py_INCREF(obj);
13731 return Py_BuildValue((char *)"");
13732 }
13733 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13734 PyObject *resultobj;
13735 wxICOHandler *result;
13736 char *kwnames[] = {
13737 NULL
13738 };
13739
13740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13741 {
13742 PyThreadState* __tstate = wxPyBeginAllowThreads();
13743 result = (wxICOHandler *)new wxICOHandler();
13744
13745 wxPyEndAllowThreads(__tstate);
13746 if (PyErr_Occurred()) SWIG_fail;
13747 }
13748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13749 return resultobj;
13750 fail:
13751 return NULL;
13752 }
13753
13754
13755 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13756 PyObject *obj;
13757 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13758 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13759 Py_INCREF(obj);
13760 return Py_BuildValue((char *)"");
13761 }
13762 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13763 PyObject *resultobj;
13764 wxCURHandler *result;
13765 char *kwnames[] = {
13766 NULL
13767 };
13768
13769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13770 {
13771 PyThreadState* __tstate = wxPyBeginAllowThreads();
13772 result = (wxCURHandler *)new wxCURHandler();
13773
13774 wxPyEndAllowThreads(__tstate);
13775 if (PyErr_Occurred()) SWIG_fail;
13776 }
13777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13778 return resultobj;
13779 fail:
13780 return NULL;
13781 }
13782
13783
13784 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13785 PyObject *obj;
13786 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13787 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13788 Py_INCREF(obj);
13789 return Py_BuildValue((char *)"");
13790 }
13791 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13792 PyObject *resultobj;
13793 wxANIHandler *result;
13794 char *kwnames[] = {
13795 NULL
13796 };
13797
13798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13799 {
13800 PyThreadState* __tstate = wxPyBeginAllowThreads();
13801 result = (wxANIHandler *)new wxANIHandler();
13802
13803 wxPyEndAllowThreads(__tstate);
13804 if (PyErr_Occurred()) SWIG_fail;
13805 }
13806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13807 return resultobj;
13808 fail:
13809 return NULL;
13810 }
13811
13812
13813 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13814 PyObject *obj;
13815 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13816 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13817 Py_INCREF(obj);
13818 return Py_BuildValue((char *)"");
13819 }
13820 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13821 PyObject *resultobj;
13822 wxPNGHandler *result;
13823 char *kwnames[] = {
13824 NULL
13825 };
13826
13827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13828 {
13829 PyThreadState* __tstate = wxPyBeginAllowThreads();
13830 result = (wxPNGHandler *)new wxPNGHandler();
13831
13832 wxPyEndAllowThreads(__tstate);
13833 if (PyErr_Occurred()) SWIG_fail;
13834 }
13835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13836 return resultobj;
13837 fail:
13838 return NULL;
13839 }
13840
13841
13842 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13843 PyObject *obj;
13844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13845 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13846 Py_INCREF(obj);
13847 return Py_BuildValue((char *)"");
13848 }
13849 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13850 PyObject *resultobj;
13851 wxGIFHandler *result;
13852 char *kwnames[] = {
13853 NULL
13854 };
13855
13856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13857 {
13858 PyThreadState* __tstate = wxPyBeginAllowThreads();
13859 result = (wxGIFHandler *)new wxGIFHandler();
13860
13861 wxPyEndAllowThreads(__tstate);
13862 if (PyErr_Occurred()) SWIG_fail;
13863 }
13864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13865 return resultobj;
13866 fail:
13867 return NULL;
13868 }
13869
13870
13871 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13872 PyObject *obj;
13873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13874 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13875 Py_INCREF(obj);
13876 return Py_BuildValue((char *)"");
13877 }
13878 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13879 PyObject *resultobj;
13880 wxPCXHandler *result;
13881 char *kwnames[] = {
13882 NULL
13883 };
13884
13885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13886 {
13887 PyThreadState* __tstate = wxPyBeginAllowThreads();
13888 result = (wxPCXHandler *)new wxPCXHandler();
13889
13890 wxPyEndAllowThreads(__tstate);
13891 if (PyErr_Occurred()) SWIG_fail;
13892 }
13893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13894 return resultobj;
13895 fail:
13896 return NULL;
13897 }
13898
13899
13900 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13901 PyObject *obj;
13902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13903 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13904 Py_INCREF(obj);
13905 return Py_BuildValue((char *)"");
13906 }
13907 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13908 PyObject *resultobj;
13909 wxJPEGHandler *result;
13910 char *kwnames[] = {
13911 NULL
13912 };
13913
13914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13915 {
13916 PyThreadState* __tstate = wxPyBeginAllowThreads();
13917 result = (wxJPEGHandler *)new wxJPEGHandler();
13918
13919 wxPyEndAllowThreads(__tstate);
13920 if (PyErr_Occurred()) SWIG_fail;
13921 }
13922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13923 return resultobj;
13924 fail:
13925 return NULL;
13926 }
13927
13928
13929 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13930 PyObject *obj;
13931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13932 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13933 Py_INCREF(obj);
13934 return Py_BuildValue((char *)"");
13935 }
13936 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13937 PyObject *resultobj;
13938 wxPNMHandler *result;
13939 char *kwnames[] = {
13940 NULL
13941 };
13942
13943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13944 {
13945 PyThreadState* __tstate = wxPyBeginAllowThreads();
13946 result = (wxPNMHandler *)new wxPNMHandler();
13947
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13959 PyObject *obj;
13960 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13961 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13962 Py_INCREF(obj);
13963 return Py_BuildValue((char *)"");
13964 }
13965 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13966 PyObject *resultobj;
13967 wxXPMHandler *result;
13968 char *kwnames[] = {
13969 NULL
13970 };
13971
13972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 result = (wxXPMHandler *)new wxXPMHandler();
13976
13977 wxPyEndAllowThreads(__tstate);
13978 if (PyErr_Occurred()) SWIG_fail;
13979 }
13980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13981 return resultobj;
13982 fail:
13983 return NULL;
13984 }
13985
13986
13987 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13988 PyObject *obj;
13989 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13990 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13991 Py_INCREF(obj);
13992 return Py_BuildValue((char *)"");
13993 }
13994 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13995 PyObject *resultobj;
13996 wxTIFFHandler *result;
13997 char *kwnames[] = {
13998 NULL
13999 };
14000
14001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14002 {
14003 PyThreadState* __tstate = wxPyBeginAllowThreads();
14004 result = (wxTIFFHandler *)new wxTIFFHandler();
14005
14006 wxPyEndAllowThreads(__tstate);
14007 if (PyErr_Occurred()) SWIG_fail;
14008 }
14009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14010 return resultobj;
14011 fail:
14012 return NULL;
14013 }
14014
14015
14016 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14017 PyObject *obj;
14018 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14019 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14020 Py_INCREF(obj);
14021 return Py_BuildValue((char *)"");
14022 }
14023 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14024 PyObject *resultobj;
14025 wxImage *arg1 = 0 ;
14026 wxImage *arg2 = 0 ;
14027 int arg3 = (int) 236 ;
14028 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14029 bool result;
14030 PyObject * obj0 = 0 ;
14031 PyObject * obj1 = 0 ;
14032 PyObject * obj2 = 0 ;
14033 PyObject * obj3 = 0 ;
14034 char *kwnames[] = {
14035 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14036 };
14037
14038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14039 {
14040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14041 if (SWIG_arg_fail(1)) SWIG_fail;
14042 if (arg1 == NULL) {
14043 SWIG_null_ref("wxImage");
14044 }
14045 if (SWIG_arg_fail(1)) SWIG_fail;
14046 }
14047 {
14048 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14049 if (SWIG_arg_fail(2)) SWIG_fail;
14050 if (arg2 == NULL) {
14051 SWIG_null_ref("wxImage");
14052 }
14053 if (SWIG_arg_fail(2)) SWIG_fail;
14054 }
14055 if (obj2) {
14056 {
14057 arg3 = (int)(SWIG_As_int(obj2));
14058 if (SWIG_arg_fail(3)) SWIG_fail;
14059 }
14060 }
14061 if (obj3) {
14062 {
14063 arg4 = (int)(SWIG_As_int(obj3));
14064 if (SWIG_arg_fail(4)) SWIG_fail;
14065 }
14066 }
14067 {
14068 PyThreadState* __tstate = wxPyBeginAllowThreads();
14069 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14070
14071 wxPyEndAllowThreads(__tstate);
14072 if (PyErr_Occurred()) SWIG_fail;
14073 }
14074 {
14075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14076 }
14077 return resultobj;
14078 fail:
14079 return NULL;
14080 }
14081
14082
14083 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14084 PyObject *obj;
14085 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14086 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14087 Py_INCREF(obj);
14088 return Py_BuildValue((char *)"");
14089 }
14090 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14091 PyObject *resultobj;
14092 wxEvtHandler *result;
14093 char *kwnames[] = {
14094 NULL
14095 };
14096
14097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14098 {
14099 PyThreadState* __tstate = wxPyBeginAllowThreads();
14100 result = (wxEvtHandler *)new wxEvtHandler();
14101
14102 wxPyEndAllowThreads(__tstate);
14103 if (PyErr_Occurred()) SWIG_fail;
14104 }
14105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14106 return resultobj;
14107 fail:
14108 return NULL;
14109 }
14110
14111
14112 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14113 PyObject *resultobj;
14114 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14115 wxEvtHandler *result;
14116 PyObject * obj0 = 0 ;
14117 char *kwnames[] = {
14118 (char *) "self", NULL
14119 };
14120
14121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14123 if (SWIG_arg_fail(1)) SWIG_fail;
14124 {
14125 PyThreadState* __tstate = wxPyBeginAllowThreads();
14126 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14127
14128 wxPyEndAllowThreads(__tstate);
14129 if (PyErr_Occurred()) SWIG_fail;
14130 }
14131 {
14132 resultobj = wxPyMake_wxObject(result, 0);
14133 }
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14141 PyObject *resultobj;
14142 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14143 wxEvtHandler *result;
14144 PyObject * obj0 = 0 ;
14145 char *kwnames[] = {
14146 (char *) "self", NULL
14147 };
14148
14149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14151 if (SWIG_arg_fail(1)) SWIG_fail;
14152 {
14153 PyThreadState* __tstate = wxPyBeginAllowThreads();
14154 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14155
14156 wxPyEndAllowThreads(__tstate);
14157 if (PyErr_Occurred()) SWIG_fail;
14158 }
14159 {
14160 resultobj = wxPyMake_wxObject(result, 0);
14161 }
14162 return resultobj;
14163 fail:
14164 return NULL;
14165 }
14166
14167
14168 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14169 PyObject *resultobj;
14170 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14171 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14172 PyObject * obj0 = 0 ;
14173 PyObject * obj1 = 0 ;
14174 char *kwnames[] = {
14175 (char *) "self",(char *) "handler", NULL
14176 };
14177
14178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14180 if (SWIG_arg_fail(1)) SWIG_fail;
14181 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14182 if (SWIG_arg_fail(2)) SWIG_fail;
14183 {
14184 PyThreadState* __tstate = wxPyBeginAllowThreads();
14185 (arg1)->SetNextHandler(arg2);
14186
14187 wxPyEndAllowThreads(__tstate);
14188 if (PyErr_Occurred()) SWIG_fail;
14189 }
14190 Py_INCREF(Py_None); resultobj = Py_None;
14191 return resultobj;
14192 fail:
14193 return NULL;
14194 }
14195
14196
14197 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14198 PyObject *resultobj;
14199 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14200 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14201 PyObject * obj0 = 0 ;
14202 PyObject * obj1 = 0 ;
14203 char *kwnames[] = {
14204 (char *) "self",(char *) "handler", NULL
14205 };
14206
14207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14209 if (SWIG_arg_fail(1)) SWIG_fail;
14210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14211 if (SWIG_arg_fail(2)) SWIG_fail;
14212 {
14213 PyThreadState* __tstate = wxPyBeginAllowThreads();
14214 (arg1)->SetPreviousHandler(arg2);
14215
14216 wxPyEndAllowThreads(__tstate);
14217 if (PyErr_Occurred()) SWIG_fail;
14218 }
14219 Py_INCREF(Py_None); resultobj = Py_None;
14220 return resultobj;
14221 fail:
14222 return NULL;
14223 }
14224
14225
14226 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14227 PyObject *resultobj;
14228 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14229 bool result;
14230 PyObject * obj0 = 0 ;
14231 char *kwnames[] = {
14232 (char *) "self", NULL
14233 };
14234
14235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14237 if (SWIG_arg_fail(1)) SWIG_fail;
14238 {
14239 PyThreadState* __tstate = wxPyBeginAllowThreads();
14240 result = (bool)(arg1)->GetEvtHandlerEnabled();
14241
14242 wxPyEndAllowThreads(__tstate);
14243 if (PyErr_Occurred()) SWIG_fail;
14244 }
14245 {
14246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14247 }
14248 return resultobj;
14249 fail:
14250 return NULL;
14251 }
14252
14253
14254 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj;
14256 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14257 bool arg2 ;
14258 PyObject * obj0 = 0 ;
14259 PyObject * obj1 = 0 ;
14260 char *kwnames[] = {
14261 (char *) "self",(char *) "enabled", NULL
14262 };
14263
14264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14266 if (SWIG_arg_fail(1)) SWIG_fail;
14267 {
14268 arg2 = (bool)(SWIG_As_bool(obj1));
14269 if (SWIG_arg_fail(2)) SWIG_fail;
14270 }
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 (arg1)->SetEvtHandlerEnabled(arg2);
14274
14275 wxPyEndAllowThreads(__tstate);
14276 if (PyErr_Occurred()) SWIG_fail;
14277 }
14278 Py_INCREF(Py_None); resultobj = Py_None;
14279 return resultobj;
14280 fail:
14281 return NULL;
14282 }
14283
14284
14285 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14286 PyObject *resultobj;
14287 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14288 wxEvent *arg2 = 0 ;
14289 bool result;
14290 PyObject * obj0 = 0 ;
14291 PyObject * obj1 = 0 ;
14292 char *kwnames[] = {
14293 (char *) "self",(char *) "event", NULL
14294 };
14295
14296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14298 if (SWIG_arg_fail(1)) SWIG_fail;
14299 {
14300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14301 if (SWIG_arg_fail(2)) SWIG_fail;
14302 if (arg2 == NULL) {
14303 SWIG_null_ref("wxEvent");
14304 }
14305 if (SWIG_arg_fail(2)) SWIG_fail;
14306 }
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 result = (bool)(arg1)->ProcessEvent(*arg2);
14310
14311 wxPyEndAllowThreads(__tstate);
14312 if (PyErr_Occurred()) SWIG_fail;
14313 }
14314 {
14315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14316 }
14317 return resultobj;
14318 fail:
14319 return NULL;
14320 }
14321
14322
14323 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14324 PyObject *resultobj;
14325 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14326 wxEvent *arg2 = 0 ;
14327 PyObject * obj0 = 0 ;
14328 PyObject * obj1 = 0 ;
14329 char *kwnames[] = {
14330 (char *) "self",(char *) "event", NULL
14331 };
14332
14333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14335 if (SWIG_arg_fail(1)) SWIG_fail;
14336 {
14337 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14338 if (SWIG_arg_fail(2)) SWIG_fail;
14339 if (arg2 == NULL) {
14340 SWIG_null_ref("wxEvent");
14341 }
14342 if (SWIG_arg_fail(2)) SWIG_fail;
14343 }
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 (arg1)->AddPendingEvent(*arg2);
14347
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 Py_INCREF(Py_None); resultobj = Py_None;
14352 return resultobj;
14353 fail:
14354 return NULL;
14355 }
14356
14357
14358 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14359 PyObject *resultobj;
14360 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14361 PyObject * obj0 = 0 ;
14362 char *kwnames[] = {
14363 (char *) "self", NULL
14364 };
14365
14366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14368 if (SWIG_arg_fail(1)) SWIG_fail;
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 (arg1)->ProcessPendingEvents();
14372
14373 wxPyEndAllowThreads(__tstate);
14374 if (PyErr_Occurred()) SWIG_fail;
14375 }
14376 Py_INCREF(Py_None); resultobj = Py_None;
14377 return resultobj;
14378 fail:
14379 return NULL;
14380 }
14381
14382
14383 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14384 PyObject *resultobj;
14385 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14386 int arg2 ;
14387 int arg3 ;
14388 int arg4 ;
14389 PyObject *arg5 = (PyObject *) 0 ;
14390 PyObject * obj0 = 0 ;
14391 PyObject * obj1 = 0 ;
14392 PyObject * obj2 = 0 ;
14393 PyObject * obj3 = 0 ;
14394 PyObject * obj4 = 0 ;
14395 char *kwnames[] = {
14396 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14397 };
14398
14399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14401 if (SWIG_arg_fail(1)) SWIG_fail;
14402 {
14403 arg2 = (int)(SWIG_As_int(obj1));
14404 if (SWIG_arg_fail(2)) SWIG_fail;
14405 }
14406 {
14407 arg3 = (int)(SWIG_As_int(obj2));
14408 if (SWIG_arg_fail(3)) SWIG_fail;
14409 }
14410 {
14411 arg4 = (int)(SWIG_As_int(obj3));
14412 if (SWIG_arg_fail(4)) SWIG_fail;
14413 }
14414 arg5 = obj4;
14415 {
14416 PyThreadState* __tstate = wxPyBeginAllowThreads();
14417 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14418
14419 wxPyEndAllowThreads(__tstate);
14420 if (PyErr_Occurred()) SWIG_fail;
14421 }
14422 Py_INCREF(Py_None); resultobj = Py_None;
14423 return resultobj;
14424 fail:
14425 return NULL;
14426 }
14427
14428
14429 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14430 PyObject *resultobj;
14431 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14432 int arg2 ;
14433 int arg3 = (int) -1 ;
14434 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14435 bool result;
14436 PyObject * obj0 = 0 ;
14437 PyObject * obj1 = 0 ;
14438 PyObject * obj2 = 0 ;
14439 PyObject * obj3 = 0 ;
14440 char *kwnames[] = {
14441 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14442 };
14443
14444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14446 if (SWIG_arg_fail(1)) SWIG_fail;
14447 {
14448 arg2 = (int)(SWIG_As_int(obj1));
14449 if (SWIG_arg_fail(2)) SWIG_fail;
14450 }
14451 if (obj2) {
14452 {
14453 arg3 = (int)(SWIG_As_int(obj2));
14454 if (SWIG_arg_fail(3)) SWIG_fail;
14455 }
14456 }
14457 if (obj3) {
14458 {
14459 arg4 = (wxEventType)(SWIG_As_int(obj3));
14460 if (SWIG_arg_fail(4)) SWIG_fail;
14461 }
14462 }
14463 {
14464 PyThreadState* __tstate = wxPyBeginAllowThreads();
14465 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14466
14467 wxPyEndAllowThreads(__tstate);
14468 if (PyErr_Occurred()) SWIG_fail;
14469 }
14470 {
14471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14472 }
14473 return resultobj;
14474 fail:
14475 return NULL;
14476 }
14477
14478
14479 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14480 PyObject *resultobj;
14481 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14482 PyObject *arg2 = (PyObject *) 0 ;
14483 bool arg3 = (bool) true ;
14484 PyObject * obj0 = 0 ;
14485 PyObject * obj1 = 0 ;
14486 PyObject * obj2 = 0 ;
14487 char *kwnames[] = {
14488 (char *) "self",(char *) "_self",(char *) "incref", NULL
14489 };
14490
14491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14493 if (SWIG_arg_fail(1)) SWIG_fail;
14494 arg2 = obj1;
14495 if (obj2) {
14496 {
14497 arg3 = (bool)(SWIG_As_bool(obj2));
14498 if (SWIG_arg_fail(3)) SWIG_fail;
14499 }
14500 }
14501 {
14502 PyThreadState* __tstate = wxPyBeginAllowThreads();
14503 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14504
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 Py_INCREF(Py_None); resultobj = Py_None;
14509 return resultobj;
14510 fail:
14511 return NULL;
14512 }
14513
14514
14515 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14516 PyObject *obj;
14517 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14518 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14519 Py_INCREF(obj);
14520 return Py_BuildValue((char *)"");
14521 }
14522 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14523 PyObject *resultobj;
14524 wxEventType result;
14525 char *kwnames[] = {
14526 NULL
14527 };
14528
14529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14530 {
14531 PyThreadState* __tstate = wxPyBeginAllowThreads();
14532 result = (wxEventType)wxNewEventType();
14533
14534 wxPyEndAllowThreads(__tstate);
14535 if (PyErr_Occurred()) SWIG_fail;
14536 }
14537 {
14538 resultobj = SWIG_From_int((int)(result));
14539 }
14540 return resultobj;
14541 fail:
14542 return NULL;
14543 }
14544
14545
14546 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14547 PyObject *resultobj;
14548 wxEvent *arg1 = (wxEvent *) 0 ;
14549 PyObject * obj0 = 0 ;
14550 char *kwnames[] = {
14551 (char *) "self", NULL
14552 };
14553
14554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14556 if (SWIG_arg_fail(1)) SWIG_fail;
14557 {
14558 PyThreadState* __tstate = wxPyBeginAllowThreads();
14559 delete arg1;
14560
14561 wxPyEndAllowThreads(__tstate);
14562 if (PyErr_Occurred()) SWIG_fail;
14563 }
14564 Py_INCREF(Py_None); resultobj = Py_None;
14565 return resultobj;
14566 fail:
14567 return NULL;
14568 }
14569
14570
14571 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14572 PyObject *resultobj;
14573 wxEvent *arg1 = (wxEvent *) 0 ;
14574 wxEventType arg2 ;
14575 PyObject * obj0 = 0 ;
14576 PyObject * obj1 = 0 ;
14577 char *kwnames[] = {
14578 (char *) "self",(char *) "typ", NULL
14579 };
14580
14581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14583 if (SWIG_arg_fail(1)) SWIG_fail;
14584 {
14585 arg2 = (wxEventType)(SWIG_As_int(obj1));
14586 if (SWIG_arg_fail(2)) SWIG_fail;
14587 }
14588 {
14589 PyThreadState* __tstate = wxPyBeginAllowThreads();
14590 (arg1)->SetEventType(arg2);
14591
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 Py_INCREF(Py_None); resultobj = Py_None;
14596 return resultobj;
14597 fail:
14598 return NULL;
14599 }
14600
14601
14602 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14603 PyObject *resultobj;
14604 wxEvent *arg1 = (wxEvent *) 0 ;
14605 wxEventType result;
14606 PyObject * obj0 = 0 ;
14607 char *kwnames[] = {
14608 (char *) "self", NULL
14609 };
14610
14611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14613 if (SWIG_arg_fail(1)) SWIG_fail;
14614 {
14615 PyThreadState* __tstate = wxPyBeginAllowThreads();
14616 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14617
14618 wxPyEndAllowThreads(__tstate);
14619 if (PyErr_Occurred()) SWIG_fail;
14620 }
14621 {
14622 resultobj = SWIG_From_int((int)(result));
14623 }
14624 return resultobj;
14625 fail:
14626 return NULL;
14627 }
14628
14629
14630 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14631 PyObject *resultobj;
14632 wxEvent *arg1 = (wxEvent *) 0 ;
14633 wxObject *result;
14634 PyObject * obj0 = 0 ;
14635 char *kwnames[] = {
14636 (char *) "self", NULL
14637 };
14638
14639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14641 if (SWIG_arg_fail(1)) SWIG_fail;
14642 {
14643 PyThreadState* __tstate = wxPyBeginAllowThreads();
14644 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14645
14646 wxPyEndAllowThreads(__tstate);
14647 if (PyErr_Occurred()) SWIG_fail;
14648 }
14649 {
14650 resultobj = wxPyMake_wxObject(result, 0);
14651 }
14652 return resultobj;
14653 fail:
14654 return NULL;
14655 }
14656
14657
14658 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14659 PyObject *resultobj;
14660 wxEvent *arg1 = (wxEvent *) 0 ;
14661 wxObject *arg2 = (wxObject *) 0 ;
14662 PyObject * obj0 = 0 ;
14663 PyObject * obj1 = 0 ;
14664 char *kwnames[] = {
14665 (char *) "self",(char *) "obj", NULL
14666 };
14667
14668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14670 if (SWIG_arg_fail(1)) SWIG_fail;
14671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14672 if (SWIG_arg_fail(2)) SWIG_fail;
14673 {
14674 PyThreadState* __tstate = wxPyBeginAllowThreads();
14675 (arg1)->SetEventObject(arg2);
14676
14677 wxPyEndAllowThreads(__tstate);
14678 if (PyErr_Occurred()) SWIG_fail;
14679 }
14680 Py_INCREF(Py_None); resultobj = Py_None;
14681 return resultobj;
14682 fail:
14683 return NULL;
14684 }
14685
14686
14687 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14688 PyObject *resultobj;
14689 wxEvent *arg1 = (wxEvent *) 0 ;
14690 long result;
14691 PyObject * obj0 = 0 ;
14692 char *kwnames[] = {
14693 (char *) "self", NULL
14694 };
14695
14696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14698 if (SWIG_arg_fail(1)) SWIG_fail;
14699 {
14700 PyThreadState* __tstate = wxPyBeginAllowThreads();
14701 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14702
14703 wxPyEndAllowThreads(__tstate);
14704 if (PyErr_Occurred()) SWIG_fail;
14705 }
14706 {
14707 resultobj = SWIG_From_long((long)(result));
14708 }
14709 return resultobj;
14710 fail:
14711 return NULL;
14712 }
14713
14714
14715 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14716 PyObject *resultobj;
14717 wxEvent *arg1 = (wxEvent *) 0 ;
14718 long arg2 = (long) 0 ;
14719 PyObject * obj0 = 0 ;
14720 PyObject * obj1 = 0 ;
14721 char *kwnames[] = {
14722 (char *) "self",(char *) "ts", NULL
14723 };
14724
14725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14727 if (SWIG_arg_fail(1)) SWIG_fail;
14728 if (obj1) {
14729 {
14730 arg2 = (long)(SWIG_As_long(obj1));
14731 if (SWIG_arg_fail(2)) SWIG_fail;
14732 }
14733 }
14734 {
14735 PyThreadState* __tstate = wxPyBeginAllowThreads();
14736 (arg1)->SetTimestamp(arg2);
14737
14738 wxPyEndAllowThreads(__tstate);
14739 if (PyErr_Occurred()) SWIG_fail;
14740 }
14741 Py_INCREF(Py_None); resultobj = Py_None;
14742 return resultobj;
14743 fail:
14744 return NULL;
14745 }
14746
14747
14748 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14749 PyObject *resultobj;
14750 wxEvent *arg1 = (wxEvent *) 0 ;
14751 int result;
14752 PyObject * obj0 = 0 ;
14753 char *kwnames[] = {
14754 (char *) "self", NULL
14755 };
14756
14757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14759 if (SWIG_arg_fail(1)) SWIG_fail;
14760 {
14761 PyThreadState* __tstate = wxPyBeginAllowThreads();
14762 result = (int)((wxEvent const *)arg1)->GetId();
14763
14764 wxPyEndAllowThreads(__tstate);
14765 if (PyErr_Occurred()) SWIG_fail;
14766 }
14767 {
14768 resultobj = SWIG_From_int((int)(result));
14769 }
14770 return resultobj;
14771 fail:
14772 return NULL;
14773 }
14774
14775
14776 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14777 PyObject *resultobj;
14778 wxEvent *arg1 = (wxEvent *) 0 ;
14779 int arg2 ;
14780 PyObject * obj0 = 0 ;
14781 PyObject * obj1 = 0 ;
14782 char *kwnames[] = {
14783 (char *) "self",(char *) "Id", NULL
14784 };
14785
14786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14788 if (SWIG_arg_fail(1)) SWIG_fail;
14789 {
14790 arg2 = (int)(SWIG_As_int(obj1));
14791 if (SWIG_arg_fail(2)) SWIG_fail;
14792 }
14793 {
14794 PyThreadState* __tstate = wxPyBeginAllowThreads();
14795 (arg1)->SetId(arg2);
14796
14797 wxPyEndAllowThreads(__tstate);
14798 if (PyErr_Occurred()) SWIG_fail;
14799 }
14800 Py_INCREF(Py_None); resultobj = Py_None;
14801 return resultobj;
14802 fail:
14803 return NULL;
14804 }
14805
14806
14807 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14808 PyObject *resultobj;
14809 wxEvent *arg1 = (wxEvent *) 0 ;
14810 bool result;
14811 PyObject * obj0 = 0 ;
14812 char *kwnames[] = {
14813 (char *) "self", NULL
14814 };
14815
14816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14818 if (SWIG_arg_fail(1)) SWIG_fail;
14819 {
14820 PyThreadState* __tstate = wxPyBeginAllowThreads();
14821 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14822
14823 wxPyEndAllowThreads(__tstate);
14824 if (PyErr_Occurred()) SWIG_fail;
14825 }
14826 {
14827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14828 }
14829 return resultobj;
14830 fail:
14831 return NULL;
14832 }
14833
14834
14835 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14836 PyObject *resultobj;
14837 wxEvent *arg1 = (wxEvent *) 0 ;
14838 bool arg2 = (bool) true ;
14839 PyObject * obj0 = 0 ;
14840 PyObject * obj1 = 0 ;
14841 char *kwnames[] = {
14842 (char *) "self",(char *) "skip", NULL
14843 };
14844
14845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14847 if (SWIG_arg_fail(1)) SWIG_fail;
14848 if (obj1) {
14849 {
14850 arg2 = (bool)(SWIG_As_bool(obj1));
14851 if (SWIG_arg_fail(2)) SWIG_fail;
14852 }
14853 }
14854 {
14855 PyThreadState* __tstate = wxPyBeginAllowThreads();
14856 (arg1)->Skip(arg2);
14857
14858 wxPyEndAllowThreads(__tstate);
14859 if (PyErr_Occurred()) SWIG_fail;
14860 }
14861 Py_INCREF(Py_None); resultobj = Py_None;
14862 return resultobj;
14863 fail:
14864 return NULL;
14865 }
14866
14867
14868 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14869 PyObject *resultobj;
14870 wxEvent *arg1 = (wxEvent *) 0 ;
14871 bool result;
14872 PyObject * obj0 = 0 ;
14873 char *kwnames[] = {
14874 (char *) "self", NULL
14875 };
14876
14877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14879 if (SWIG_arg_fail(1)) SWIG_fail;
14880 {
14881 PyThreadState* __tstate = wxPyBeginAllowThreads();
14882 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14883
14884 wxPyEndAllowThreads(__tstate);
14885 if (PyErr_Occurred()) SWIG_fail;
14886 }
14887 {
14888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14889 }
14890 return resultobj;
14891 fail:
14892 return NULL;
14893 }
14894
14895
14896 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14897 PyObject *resultobj;
14898 wxEvent *arg1 = (wxEvent *) 0 ;
14899 bool result;
14900 PyObject * obj0 = 0 ;
14901 char *kwnames[] = {
14902 (char *) "self", NULL
14903 };
14904
14905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14907 if (SWIG_arg_fail(1)) SWIG_fail;
14908 {
14909 PyThreadState* __tstate = wxPyBeginAllowThreads();
14910 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14911
14912 wxPyEndAllowThreads(__tstate);
14913 if (PyErr_Occurred()) SWIG_fail;
14914 }
14915 {
14916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14917 }
14918 return resultobj;
14919 fail:
14920 return NULL;
14921 }
14922
14923
14924 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14925 PyObject *resultobj;
14926 wxEvent *arg1 = (wxEvent *) 0 ;
14927 int result;
14928 PyObject * obj0 = 0 ;
14929 char *kwnames[] = {
14930 (char *) "self", NULL
14931 };
14932
14933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14935 if (SWIG_arg_fail(1)) SWIG_fail;
14936 {
14937 PyThreadState* __tstate = wxPyBeginAllowThreads();
14938 result = (int)(arg1)->StopPropagation();
14939
14940 wxPyEndAllowThreads(__tstate);
14941 if (PyErr_Occurred()) SWIG_fail;
14942 }
14943 {
14944 resultobj = SWIG_From_int((int)(result));
14945 }
14946 return resultobj;
14947 fail:
14948 return NULL;
14949 }
14950
14951
14952 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14953 PyObject *resultobj;
14954 wxEvent *arg1 = (wxEvent *) 0 ;
14955 int arg2 ;
14956 PyObject * obj0 = 0 ;
14957 PyObject * obj1 = 0 ;
14958 char *kwnames[] = {
14959 (char *) "self",(char *) "propagationLevel", NULL
14960 };
14961
14962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14964 if (SWIG_arg_fail(1)) SWIG_fail;
14965 {
14966 arg2 = (int)(SWIG_As_int(obj1));
14967 if (SWIG_arg_fail(2)) SWIG_fail;
14968 }
14969 {
14970 PyThreadState* __tstate = wxPyBeginAllowThreads();
14971 (arg1)->ResumePropagation(arg2);
14972
14973 wxPyEndAllowThreads(__tstate);
14974 if (PyErr_Occurred()) SWIG_fail;
14975 }
14976 Py_INCREF(Py_None); resultobj = Py_None;
14977 return resultobj;
14978 fail:
14979 return NULL;
14980 }
14981
14982
14983 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14984 PyObject *resultobj;
14985 wxEvent *arg1 = (wxEvent *) 0 ;
14986 wxEvent *result;
14987 PyObject * obj0 = 0 ;
14988 char *kwnames[] = {
14989 (char *) "self", NULL
14990 };
14991
14992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14994 if (SWIG_arg_fail(1)) SWIG_fail;
14995 {
14996 PyThreadState* __tstate = wxPyBeginAllowThreads();
14997 result = (wxEvent *)(arg1)->Clone();
14998
14999 wxPyEndAllowThreads(__tstate);
15000 if (PyErr_Occurred()) SWIG_fail;
15001 }
15002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15003 return resultobj;
15004 fail:
15005 return NULL;
15006 }
15007
15008
15009 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15010 PyObject *obj;
15011 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15012 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15013 Py_INCREF(obj);
15014 return Py_BuildValue((char *)"");
15015 }
15016 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15017 PyObject *resultobj;
15018 wxEvent *arg1 = 0 ;
15019 wxPropagationDisabler *result;
15020 PyObject * obj0 = 0 ;
15021 char *kwnames[] = {
15022 (char *) "event", NULL
15023 };
15024
15025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15026 {
15027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15028 if (SWIG_arg_fail(1)) SWIG_fail;
15029 if (arg1 == NULL) {
15030 SWIG_null_ref("wxEvent");
15031 }
15032 if (SWIG_arg_fail(1)) SWIG_fail;
15033 }
15034 {
15035 PyThreadState* __tstate = wxPyBeginAllowThreads();
15036 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15037
15038 wxPyEndAllowThreads(__tstate);
15039 if (PyErr_Occurred()) SWIG_fail;
15040 }
15041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15042 return resultobj;
15043 fail:
15044 return NULL;
15045 }
15046
15047
15048 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15049 PyObject *resultobj;
15050 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15051 PyObject * obj0 = 0 ;
15052 char *kwnames[] = {
15053 (char *) "self", NULL
15054 };
15055
15056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15058 if (SWIG_arg_fail(1)) SWIG_fail;
15059 {
15060 PyThreadState* __tstate = wxPyBeginAllowThreads();
15061 delete arg1;
15062
15063 wxPyEndAllowThreads(__tstate);
15064 if (PyErr_Occurred()) SWIG_fail;
15065 }
15066 Py_INCREF(Py_None); resultobj = Py_None;
15067 return resultobj;
15068 fail:
15069 return NULL;
15070 }
15071
15072
15073 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15074 PyObject *obj;
15075 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15076 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15077 Py_INCREF(obj);
15078 return Py_BuildValue((char *)"");
15079 }
15080 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15081 PyObject *resultobj;
15082 wxEvent *arg1 = 0 ;
15083 wxPropagateOnce *result;
15084 PyObject * obj0 = 0 ;
15085 char *kwnames[] = {
15086 (char *) "event", NULL
15087 };
15088
15089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15090 {
15091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15092 if (SWIG_arg_fail(1)) SWIG_fail;
15093 if (arg1 == NULL) {
15094 SWIG_null_ref("wxEvent");
15095 }
15096 if (SWIG_arg_fail(1)) SWIG_fail;
15097 }
15098 {
15099 PyThreadState* __tstate = wxPyBeginAllowThreads();
15100 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15101
15102 wxPyEndAllowThreads(__tstate);
15103 if (PyErr_Occurred()) SWIG_fail;
15104 }
15105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15106 return resultobj;
15107 fail:
15108 return NULL;
15109 }
15110
15111
15112 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15113 PyObject *resultobj;
15114 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15115 PyObject * obj0 = 0 ;
15116 char *kwnames[] = {
15117 (char *) "self", NULL
15118 };
15119
15120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15122 if (SWIG_arg_fail(1)) SWIG_fail;
15123 {
15124 PyThreadState* __tstate = wxPyBeginAllowThreads();
15125 delete arg1;
15126
15127 wxPyEndAllowThreads(__tstate);
15128 if (PyErr_Occurred()) SWIG_fail;
15129 }
15130 Py_INCREF(Py_None); resultobj = Py_None;
15131 return resultobj;
15132 fail:
15133 return NULL;
15134 }
15135
15136
15137 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15138 PyObject *obj;
15139 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15140 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15141 Py_INCREF(obj);
15142 return Py_BuildValue((char *)"");
15143 }
15144 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15145 PyObject *resultobj;
15146 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15147 int arg2 = (int) 0 ;
15148 wxCommandEvent *result;
15149 PyObject * obj0 = 0 ;
15150 PyObject * obj1 = 0 ;
15151 char *kwnames[] = {
15152 (char *) "commandType",(char *) "winid", NULL
15153 };
15154
15155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15156 if (obj0) {
15157 {
15158 arg1 = (wxEventType)(SWIG_As_int(obj0));
15159 if (SWIG_arg_fail(1)) SWIG_fail;
15160 }
15161 }
15162 if (obj1) {
15163 {
15164 arg2 = (int)(SWIG_As_int(obj1));
15165 if (SWIG_arg_fail(2)) SWIG_fail;
15166 }
15167 }
15168 {
15169 PyThreadState* __tstate = wxPyBeginAllowThreads();
15170 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15171
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15176 return resultobj;
15177 fail:
15178 return NULL;
15179 }
15180
15181
15182 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15183 PyObject *resultobj;
15184 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15185 int result;
15186 PyObject * obj0 = 0 ;
15187 char *kwnames[] = {
15188 (char *) "self", NULL
15189 };
15190
15191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15193 if (SWIG_arg_fail(1)) SWIG_fail;
15194 {
15195 PyThreadState* __tstate = wxPyBeginAllowThreads();
15196 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15197
15198 wxPyEndAllowThreads(__tstate);
15199 if (PyErr_Occurred()) SWIG_fail;
15200 }
15201 {
15202 resultobj = SWIG_From_int((int)(result));
15203 }
15204 return resultobj;
15205 fail:
15206 return NULL;
15207 }
15208
15209
15210 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15211 PyObject *resultobj;
15212 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15213 wxString *arg2 = 0 ;
15214 bool temp2 = false ;
15215 PyObject * obj0 = 0 ;
15216 PyObject * obj1 = 0 ;
15217 char *kwnames[] = {
15218 (char *) "self",(char *) "s", NULL
15219 };
15220
15221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15223 if (SWIG_arg_fail(1)) SWIG_fail;
15224 {
15225 arg2 = wxString_in_helper(obj1);
15226 if (arg2 == NULL) SWIG_fail;
15227 temp2 = true;
15228 }
15229 {
15230 PyThreadState* __tstate = wxPyBeginAllowThreads();
15231 (arg1)->SetString((wxString const &)*arg2);
15232
15233 wxPyEndAllowThreads(__tstate);
15234 if (PyErr_Occurred()) SWIG_fail;
15235 }
15236 Py_INCREF(Py_None); resultobj = Py_None;
15237 {
15238 if (temp2)
15239 delete arg2;
15240 }
15241 return resultobj;
15242 fail:
15243 {
15244 if (temp2)
15245 delete arg2;
15246 }
15247 return NULL;
15248 }
15249
15250
15251 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15252 PyObject *resultobj;
15253 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15254 wxString result;
15255 PyObject * obj0 = 0 ;
15256 char *kwnames[] = {
15257 (char *) "self", NULL
15258 };
15259
15260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15262 if (SWIG_arg_fail(1)) SWIG_fail;
15263 {
15264 PyThreadState* __tstate = wxPyBeginAllowThreads();
15265 result = ((wxCommandEvent const *)arg1)->GetString();
15266
15267 wxPyEndAllowThreads(__tstate);
15268 if (PyErr_Occurred()) SWIG_fail;
15269 }
15270 {
15271 #if wxUSE_UNICODE
15272 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15273 #else
15274 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15275 #endif
15276 }
15277 return resultobj;
15278 fail:
15279 return NULL;
15280 }
15281
15282
15283 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15284 PyObject *resultobj;
15285 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15286 bool result;
15287 PyObject * obj0 = 0 ;
15288 char *kwnames[] = {
15289 (char *) "self", NULL
15290 };
15291
15292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15294 if (SWIG_arg_fail(1)) SWIG_fail;
15295 {
15296 PyThreadState* __tstate = wxPyBeginAllowThreads();
15297 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15298
15299 wxPyEndAllowThreads(__tstate);
15300 if (PyErr_Occurred()) SWIG_fail;
15301 }
15302 {
15303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15304 }
15305 return resultobj;
15306 fail:
15307 return NULL;
15308 }
15309
15310
15311 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15312 PyObject *resultobj;
15313 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15314 bool result;
15315 PyObject * obj0 = 0 ;
15316 char *kwnames[] = {
15317 (char *) "self", NULL
15318 };
15319
15320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15322 if (SWIG_arg_fail(1)) SWIG_fail;
15323 {
15324 PyThreadState* __tstate = wxPyBeginAllowThreads();
15325 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15326
15327 wxPyEndAllowThreads(__tstate);
15328 if (PyErr_Occurred()) SWIG_fail;
15329 }
15330 {
15331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15332 }
15333 return resultobj;
15334 fail:
15335 return NULL;
15336 }
15337
15338
15339 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15340 PyObject *resultobj;
15341 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15342 long arg2 ;
15343 PyObject * obj0 = 0 ;
15344 PyObject * obj1 = 0 ;
15345 char *kwnames[] = {
15346 (char *) "self",(char *) "extraLong", NULL
15347 };
15348
15349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15351 if (SWIG_arg_fail(1)) SWIG_fail;
15352 {
15353 arg2 = (long)(SWIG_As_long(obj1));
15354 if (SWIG_arg_fail(2)) SWIG_fail;
15355 }
15356 {
15357 PyThreadState* __tstate = wxPyBeginAllowThreads();
15358 (arg1)->SetExtraLong(arg2);
15359
15360 wxPyEndAllowThreads(__tstate);
15361 if (PyErr_Occurred()) SWIG_fail;
15362 }
15363 Py_INCREF(Py_None); resultobj = Py_None;
15364 return resultobj;
15365 fail:
15366 return NULL;
15367 }
15368
15369
15370 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15371 PyObject *resultobj;
15372 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15373 long result;
15374 PyObject * obj0 = 0 ;
15375 char *kwnames[] = {
15376 (char *) "self", NULL
15377 };
15378
15379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15381 if (SWIG_arg_fail(1)) SWIG_fail;
15382 {
15383 PyThreadState* __tstate = wxPyBeginAllowThreads();
15384 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15385
15386 wxPyEndAllowThreads(__tstate);
15387 if (PyErr_Occurred()) SWIG_fail;
15388 }
15389 {
15390 resultobj = SWIG_From_long((long)(result));
15391 }
15392 return resultobj;
15393 fail:
15394 return NULL;
15395 }
15396
15397
15398 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15399 PyObject *resultobj;
15400 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15401 int arg2 ;
15402 PyObject * obj0 = 0 ;
15403 PyObject * obj1 = 0 ;
15404 char *kwnames[] = {
15405 (char *) "self",(char *) "i", NULL
15406 };
15407
15408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15410 if (SWIG_arg_fail(1)) SWIG_fail;
15411 {
15412 arg2 = (int)(SWIG_As_int(obj1));
15413 if (SWIG_arg_fail(2)) SWIG_fail;
15414 }
15415 {
15416 PyThreadState* __tstate = wxPyBeginAllowThreads();
15417 (arg1)->SetInt(arg2);
15418
15419 wxPyEndAllowThreads(__tstate);
15420 if (PyErr_Occurred()) SWIG_fail;
15421 }
15422 Py_INCREF(Py_None); resultobj = Py_None;
15423 return resultobj;
15424 fail:
15425 return NULL;
15426 }
15427
15428
15429 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15430 PyObject *resultobj;
15431 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15432 long result;
15433 PyObject * obj0 = 0 ;
15434 char *kwnames[] = {
15435 (char *) "self", NULL
15436 };
15437
15438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15440 if (SWIG_arg_fail(1)) SWIG_fail;
15441 {
15442 PyThreadState* __tstate = wxPyBeginAllowThreads();
15443 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15444
15445 wxPyEndAllowThreads(__tstate);
15446 if (PyErr_Occurred()) SWIG_fail;
15447 }
15448 {
15449 resultobj = SWIG_From_long((long)(result));
15450 }
15451 return resultobj;
15452 fail:
15453 return NULL;
15454 }
15455
15456
15457 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15458 PyObject *resultobj;
15459 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15460 wxEvent *result;
15461 PyObject * obj0 = 0 ;
15462 char *kwnames[] = {
15463 (char *) "self", NULL
15464 };
15465
15466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15468 if (SWIG_arg_fail(1)) SWIG_fail;
15469 {
15470 PyThreadState* __tstate = wxPyBeginAllowThreads();
15471 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15472
15473 wxPyEndAllowThreads(__tstate);
15474 if (PyErr_Occurred()) SWIG_fail;
15475 }
15476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15477 return resultobj;
15478 fail:
15479 return NULL;
15480 }
15481
15482
15483 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15484 PyObject *obj;
15485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15486 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15487 Py_INCREF(obj);
15488 return Py_BuildValue((char *)"");
15489 }
15490 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15491 PyObject *resultobj;
15492 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15493 int arg2 = (int) 0 ;
15494 wxNotifyEvent *result;
15495 PyObject * obj0 = 0 ;
15496 PyObject * obj1 = 0 ;
15497 char *kwnames[] = {
15498 (char *) "commandType",(char *) "winid", NULL
15499 };
15500
15501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15502 if (obj0) {
15503 {
15504 arg1 = (wxEventType)(SWIG_As_int(obj0));
15505 if (SWIG_arg_fail(1)) SWIG_fail;
15506 }
15507 }
15508 if (obj1) {
15509 {
15510 arg2 = (int)(SWIG_As_int(obj1));
15511 if (SWIG_arg_fail(2)) SWIG_fail;
15512 }
15513 }
15514 {
15515 PyThreadState* __tstate = wxPyBeginAllowThreads();
15516 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15517
15518 wxPyEndAllowThreads(__tstate);
15519 if (PyErr_Occurred()) SWIG_fail;
15520 }
15521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15522 return resultobj;
15523 fail:
15524 return NULL;
15525 }
15526
15527
15528 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15529 PyObject *resultobj;
15530 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15531 PyObject * obj0 = 0 ;
15532 char *kwnames[] = {
15533 (char *) "self", NULL
15534 };
15535
15536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15538 if (SWIG_arg_fail(1)) SWIG_fail;
15539 {
15540 PyThreadState* __tstate = wxPyBeginAllowThreads();
15541 (arg1)->Veto();
15542
15543 wxPyEndAllowThreads(__tstate);
15544 if (PyErr_Occurred()) SWIG_fail;
15545 }
15546 Py_INCREF(Py_None); resultobj = Py_None;
15547 return resultobj;
15548 fail:
15549 return NULL;
15550 }
15551
15552
15553 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15554 PyObject *resultobj;
15555 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15556 PyObject * obj0 = 0 ;
15557 char *kwnames[] = {
15558 (char *) "self", NULL
15559 };
15560
15561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15563 if (SWIG_arg_fail(1)) SWIG_fail;
15564 {
15565 PyThreadState* __tstate = wxPyBeginAllowThreads();
15566 (arg1)->Allow();
15567
15568 wxPyEndAllowThreads(__tstate);
15569 if (PyErr_Occurred()) SWIG_fail;
15570 }
15571 Py_INCREF(Py_None); resultobj = Py_None;
15572 return resultobj;
15573 fail:
15574 return NULL;
15575 }
15576
15577
15578 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15579 PyObject *resultobj;
15580 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15581 bool result;
15582 PyObject * obj0 = 0 ;
15583 char *kwnames[] = {
15584 (char *) "self", NULL
15585 };
15586
15587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15589 if (SWIG_arg_fail(1)) SWIG_fail;
15590 {
15591 PyThreadState* __tstate = wxPyBeginAllowThreads();
15592 result = (bool)(arg1)->IsAllowed();
15593
15594 wxPyEndAllowThreads(__tstate);
15595 if (PyErr_Occurred()) SWIG_fail;
15596 }
15597 {
15598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15599 }
15600 return resultobj;
15601 fail:
15602 return NULL;
15603 }
15604
15605
15606 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15607 PyObject *obj;
15608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15609 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15610 Py_INCREF(obj);
15611 return Py_BuildValue((char *)"");
15612 }
15613 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15614 PyObject *resultobj;
15615 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15616 int arg2 = (int) 0 ;
15617 int arg3 = (int) 0 ;
15618 int arg4 = (int) 0 ;
15619 wxScrollEvent *result;
15620 PyObject * obj0 = 0 ;
15621 PyObject * obj1 = 0 ;
15622 PyObject * obj2 = 0 ;
15623 PyObject * obj3 = 0 ;
15624 char *kwnames[] = {
15625 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15626 };
15627
15628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15629 if (obj0) {
15630 {
15631 arg1 = (wxEventType)(SWIG_As_int(obj0));
15632 if (SWIG_arg_fail(1)) SWIG_fail;
15633 }
15634 }
15635 if (obj1) {
15636 {
15637 arg2 = (int)(SWIG_As_int(obj1));
15638 if (SWIG_arg_fail(2)) SWIG_fail;
15639 }
15640 }
15641 if (obj2) {
15642 {
15643 arg3 = (int)(SWIG_As_int(obj2));
15644 if (SWIG_arg_fail(3)) SWIG_fail;
15645 }
15646 }
15647 if (obj3) {
15648 {
15649 arg4 = (int)(SWIG_As_int(obj3));
15650 if (SWIG_arg_fail(4)) SWIG_fail;
15651 }
15652 }
15653 {
15654 PyThreadState* __tstate = wxPyBeginAllowThreads();
15655 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15656
15657 wxPyEndAllowThreads(__tstate);
15658 if (PyErr_Occurred()) SWIG_fail;
15659 }
15660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15661 return resultobj;
15662 fail:
15663 return NULL;
15664 }
15665
15666
15667 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15668 PyObject *resultobj;
15669 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15670 int result;
15671 PyObject * obj0 = 0 ;
15672 char *kwnames[] = {
15673 (char *) "self", NULL
15674 };
15675
15676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15678 if (SWIG_arg_fail(1)) SWIG_fail;
15679 {
15680 PyThreadState* __tstate = wxPyBeginAllowThreads();
15681 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15682
15683 wxPyEndAllowThreads(__tstate);
15684 if (PyErr_Occurred()) SWIG_fail;
15685 }
15686 {
15687 resultobj = SWIG_From_int((int)(result));
15688 }
15689 return resultobj;
15690 fail:
15691 return NULL;
15692 }
15693
15694
15695 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15696 PyObject *resultobj;
15697 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15698 int result;
15699 PyObject * obj0 = 0 ;
15700 char *kwnames[] = {
15701 (char *) "self", NULL
15702 };
15703
15704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15706 if (SWIG_arg_fail(1)) SWIG_fail;
15707 {
15708 PyThreadState* __tstate = wxPyBeginAllowThreads();
15709 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15710
15711 wxPyEndAllowThreads(__tstate);
15712 if (PyErr_Occurred()) SWIG_fail;
15713 }
15714 {
15715 resultobj = SWIG_From_int((int)(result));
15716 }
15717 return resultobj;
15718 fail:
15719 return NULL;
15720 }
15721
15722
15723 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15724 PyObject *resultobj;
15725 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15726 int arg2 ;
15727 PyObject * obj0 = 0 ;
15728 PyObject * obj1 = 0 ;
15729 char *kwnames[] = {
15730 (char *) "self",(char *) "orient", NULL
15731 };
15732
15733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15735 if (SWIG_arg_fail(1)) SWIG_fail;
15736 {
15737 arg2 = (int)(SWIG_As_int(obj1));
15738 if (SWIG_arg_fail(2)) SWIG_fail;
15739 }
15740 {
15741 PyThreadState* __tstate = wxPyBeginAllowThreads();
15742 (arg1)->SetOrientation(arg2);
15743
15744 wxPyEndAllowThreads(__tstate);
15745 if (PyErr_Occurred()) SWIG_fail;
15746 }
15747 Py_INCREF(Py_None); resultobj = Py_None;
15748 return resultobj;
15749 fail:
15750 return NULL;
15751 }
15752
15753
15754 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15755 PyObject *resultobj;
15756 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15757 int arg2 ;
15758 PyObject * obj0 = 0 ;
15759 PyObject * obj1 = 0 ;
15760 char *kwnames[] = {
15761 (char *) "self",(char *) "pos", NULL
15762 };
15763
15764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15766 if (SWIG_arg_fail(1)) SWIG_fail;
15767 {
15768 arg2 = (int)(SWIG_As_int(obj1));
15769 if (SWIG_arg_fail(2)) SWIG_fail;
15770 }
15771 {
15772 PyThreadState* __tstate = wxPyBeginAllowThreads();
15773 (arg1)->SetPosition(arg2);
15774
15775 wxPyEndAllowThreads(__tstate);
15776 if (PyErr_Occurred()) SWIG_fail;
15777 }
15778 Py_INCREF(Py_None); resultobj = Py_None;
15779 return resultobj;
15780 fail:
15781 return NULL;
15782 }
15783
15784
15785 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15786 PyObject *obj;
15787 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15788 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15789 Py_INCREF(obj);
15790 return Py_BuildValue((char *)"");
15791 }
15792 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15793 PyObject *resultobj;
15794 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15795 int arg2 = (int) 0 ;
15796 int arg3 = (int) 0 ;
15797 wxScrollWinEvent *result;
15798 PyObject * obj0 = 0 ;
15799 PyObject * obj1 = 0 ;
15800 PyObject * obj2 = 0 ;
15801 char *kwnames[] = {
15802 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15803 };
15804
15805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15806 if (obj0) {
15807 {
15808 arg1 = (wxEventType)(SWIG_As_int(obj0));
15809 if (SWIG_arg_fail(1)) SWIG_fail;
15810 }
15811 }
15812 if (obj1) {
15813 {
15814 arg2 = (int)(SWIG_As_int(obj1));
15815 if (SWIG_arg_fail(2)) SWIG_fail;
15816 }
15817 }
15818 if (obj2) {
15819 {
15820 arg3 = (int)(SWIG_As_int(obj2));
15821 if (SWIG_arg_fail(3)) SWIG_fail;
15822 }
15823 }
15824 {
15825 PyThreadState* __tstate = wxPyBeginAllowThreads();
15826 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15827
15828 wxPyEndAllowThreads(__tstate);
15829 if (PyErr_Occurred()) SWIG_fail;
15830 }
15831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15832 return resultobj;
15833 fail:
15834 return NULL;
15835 }
15836
15837
15838 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15839 PyObject *resultobj;
15840 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15841 int result;
15842 PyObject * obj0 = 0 ;
15843 char *kwnames[] = {
15844 (char *) "self", NULL
15845 };
15846
15847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15849 if (SWIG_arg_fail(1)) SWIG_fail;
15850 {
15851 PyThreadState* __tstate = wxPyBeginAllowThreads();
15852 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15853
15854 wxPyEndAllowThreads(__tstate);
15855 if (PyErr_Occurred()) SWIG_fail;
15856 }
15857 {
15858 resultobj = SWIG_From_int((int)(result));
15859 }
15860 return resultobj;
15861 fail:
15862 return NULL;
15863 }
15864
15865
15866 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15867 PyObject *resultobj;
15868 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15869 int result;
15870 PyObject * obj0 = 0 ;
15871 char *kwnames[] = {
15872 (char *) "self", NULL
15873 };
15874
15875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15877 if (SWIG_arg_fail(1)) SWIG_fail;
15878 {
15879 PyThreadState* __tstate = wxPyBeginAllowThreads();
15880 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15881
15882 wxPyEndAllowThreads(__tstate);
15883 if (PyErr_Occurred()) SWIG_fail;
15884 }
15885 {
15886 resultobj = SWIG_From_int((int)(result));
15887 }
15888 return resultobj;
15889 fail:
15890 return NULL;
15891 }
15892
15893
15894 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15895 PyObject *resultobj;
15896 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15897 int arg2 ;
15898 PyObject * obj0 = 0 ;
15899 PyObject * obj1 = 0 ;
15900 char *kwnames[] = {
15901 (char *) "self",(char *) "orient", NULL
15902 };
15903
15904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15906 if (SWIG_arg_fail(1)) SWIG_fail;
15907 {
15908 arg2 = (int)(SWIG_As_int(obj1));
15909 if (SWIG_arg_fail(2)) SWIG_fail;
15910 }
15911 {
15912 PyThreadState* __tstate = wxPyBeginAllowThreads();
15913 (arg1)->SetOrientation(arg2);
15914
15915 wxPyEndAllowThreads(__tstate);
15916 if (PyErr_Occurred()) SWIG_fail;
15917 }
15918 Py_INCREF(Py_None); resultobj = Py_None;
15919 return resultobj;
15920 fail:
15921 return NULL;
15922 }
15923
15924
15925 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15926 PyObject *resultobj;
15927 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15928 int arg2 ;
15929 PyObject * obj0 = 0 ;
15930 PyObject * obj1 = 0 ;
15931 char *kwnames[] = {
15932 (char *) "self",(char *) "pos", NULL
15933 };
15934
15935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15937 if (SWIG_arg_fail(1)) SWIG_fail;
15938 {
15939 arg2 = (int)(SWIG_As_int(obj1));
15940 if (SWIG_arg_fail(2)) SWIG_fail;
15941 }
15942 {
15943 PyThreadState* __tstate = wxPyBeginAllowThreads();
15944 (arg1)->SetPosition(arg2);
15945
15946 wxPyEndAllowThreads(__tstate);
15947 if (PyErr_Occurred()) SWIG_fail;
15948 }
15949 Py_INCREF(Py_None); resultobj = Py_None;
15950 return resultobj;
15951 fail:
15952 return NULL;
15953 }
15954
15955
15956 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15957 PyObject *obj;
15958 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15959 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15960 Py_INCREF(obj);
15961 return Py_BuildValue((char *)"");
15962 }
15963 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15964 PyObject *resultobj;
15965 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15966 wxMouseEvent *result;
15967 PyObject * obj0 = 0 ;
15968 char *kwnames[] = {
15969 (char *) "mouseType", NULL
15970 };
15971
15972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15973 if (obj0) {
15974 {
15975 arg1 = (wxEventType)(SWIG_As_int(obj0));
15976 if (SWIG_arg_fail(1)) SWIG_fail;
15977 }
15978 }
15979 {
15980 PyThreadState* __tstate = wxPyBeginAllowThreads();
15981 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15982
15983 wxPyEndAllowThreads(__tstate);
15984 if (PyErr_Occurred()) SWIG_fail;
15985 }
15986 {
15987 resultobj = wxPyMake_wxObject(result, 1);
15988 }
15989 return resultobj;
15990 fail:
15991 return NULL;
15992 }
15993
15994
15995 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15996 PyObject *resultobj;
15997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15998 bool result;
15999 PyObject * obj0 = 0 ;
16000 char *kwnames[] = {
16001 (char *) "self", NULL
16002 };
16003
16004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16006 if (SWIG_arg_fail(1)) SWIG_fail;
16007 {
16008 PyThreadState* __tstate = wxPyBeginAllowThreads();
16009 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16010
16011 wxPyEndAllowThreads(__tstate);
16012 if (PyErr_Occurred()) SWIG_fail;
16013 }
16014 {
16015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16016 }
16017 return resultobj;
16018 fail:
16019 return NULL;
16020 }
16021
16022
16023 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16024 PyObject *resultobj;
16025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16026 int arg2 = (int) wxMOUSE_BTN_ANY ;
16027 bool result;
16028 PyObject * obj0 = 0 ;
16029 PyObject * obj1 = 0 ;
16030 char *kwnames[] = {
16031 (char *) "self",(char *) "but", NULL
16032 };
16033
16034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16036 if (SWIG_arg_fail(1)) SWIG_fail;
16037 if (obj1) {
16038 {
16039 arg2 = (int)(SWIG_As_int(obj1));
16040 if (SWIG_arg_fail(2)) SWIG_fail;
16041 }
16042 }
16043 {
16044 PyThreadState* __tstate = wxPyBeginAllowThreads();
16045 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16046
16047 wxPyEndAllowThreads(__tstate);
16048 if (PyErr_Occurred()) SWIG_fail;
16049 }
16050 {
16051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16052 }
16053 return resultobj;
16054 fail:
16055 return NULL;
16056 }
16057
16058
16059 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16060 PyObject *resultobj;
16061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16062 int arg2 = (int) wxMOUSE_BTN_ANY ;
16063 bool result;
16064 PyObject * obj0 = 0 ;
16065 PyObject * obj1 = 0 ;
16066 char *kwnames[] = {
16067 (char *) "self",(char *) "but", NULL
16068 };
16069
16070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16072 if (SWIG_arg_fail(1)) SWIG_fail;
16073 if (obj1) {
16074 {
16075 arg2 = (int)(SWIG_As_int(obj1));
16076 if (SWIG_arg_fail(2)) SWIG_fail;
16077 }
16078 }
16079 {
16080 PyThreadState* __tstate = wxPyBeginAllowThreads();
16081 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16082
16083 wxPyEndAllowThreads(__tstate);
16084 if (PyErr_Occurred()) SWIG_fail;
16085 }
16086 {
16087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16088 }
16089 return resultobj;
16090 fail:
16091 return NULL;
16092 }
16093
16094
16095 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16096 PyObject *resultobj;
16097 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16098 int arg2 = (int) wxMOUSE_BTN_ANY ;
16099 bool result;
16100 PyObject * obj0 = 0 ;
16101 PyObject * obj1 = 0 ;
16102 char *kwnames[] = {
16103 (char *) "self",(char *) "but", NULL
16104 };
16105
16106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16108 if (SWIG_arg_fail(1)) SWIG_fail;
16109 if (obj1) {
16110 {
16111 arg2 = (int)(SWIG_As_int(obj1));
16112 if (SWIG_arg_fail(2)) SWIG_fail;
16113 }
16114 }
16115 {
16116 PyThreadState* __tstate = wxPyBeginAllowThreads();
16117 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16118
16119 wxPyEndAllowThreads(__tstate);
16120 if (PyErr_Occurred()) SWIG_fail;
16121 }
16122 {
16123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16124 }
16125 return resultobj;
16126 fail:
16127 return NULL;
16128 }
16129
16130
16131 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16132 PyObject *resultobj;
16133 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16134 int arg2 ;
16135 bool result;
16136 PyObject * obj0 = 0 ;
16137 PyObject * obj1 = 0 ;
16138 char *kwnames[] = {
16139 (char *) "self",(char *) "but", NULL
16140 };
16141
16142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16144 if (SWIG_arg_fail(1)) SWIG_fail;
16145 {
16146 arg2 = (int)(SWIG_As_int(obj1));
16147 if (SWIG_arg_fail(2)) SWIG_fail;
16148 }
16149 {
16150 PyThreadState* __tstate = wxPyBeginAllowThreads();
16151 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16152
16153 wxPyEndAllowThreads(__tstate);
16154 if (PyErr_Occurred()) SWIG_fail;
16155 }
16156 {
16157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16158 }
16159 return resultobj;
16160 fail:
16161 return NULL;
16162 }
16163
16164
16165 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16166 PyObject *resultobj;
16167 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16168 int arg2 ;
16169 bool result;
16170 PyObject * obj0 = 0 ;
16171 PyObject * obj1 = 0 ;
16172 char *kwnames[] = {
16173 (char *) "self",(char *) "but", NULL
16174 };
16175
16176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16178 if (SWIG_arg_fail(1)) SWIG_fail;
16179 {
16180 arg2 = (int)(SWIG_As_int(obj1));
16181 if (SWIG_arg_fail(2)) SWIG_fail;
16182 }
16183 {
16184 PyThreadState* __tstate = wxPyBeginAllowThreads();
16185 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16186
16187 wxPyEndAllowThreads(__tstate);
16188 if (PyErr_Occurred()) SWIG_fail;
16189 }
16190 {
16191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16192 }
16193 return resultobj;
16194 fail:
16195 return NULL;
16196 }
16197
16198
16199 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16200 PyObject *resultobj;
16201 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16202 int result;
16203 PyObject * obj0 = 0 ;
16204 char *kwnames[] = {
16205 (char *) "self", NULL
16206 };
16207
16208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16210 if (SWIG_arg_fail(1)) SWIG_fail;
16211 {
16212 PyThreadState* __tstate = wxPyBeginAllowThreads();
16213 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16214
16215 wxPyEndAllowThreads(__tstate);
16216 if (PyErr_Occurred()) SWIG_fail;
16217 }
16218 {
16219 resultobj = SWIG_From_int((int)(result));
16220 }
16221 return resultobj;
16222 fail:
16223 return NULL;
16224 }
16225
16226
16227 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16228 PyObject *resultobj;
16229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16230 bool result;
16231 PyObject * obj0 = 0 ;
16232 char *kwnames[] = {
16233 (char *) "self", NULL
16234 };
16235
16236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16238 if (SWIG_arg_fail(1)) SWIG_fail;
16239 {
16240 PyThreadState* __tstate = wxPyBeginAllowThreads();
16241 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16242
16243 wxPyEndAllowThreads(__tstate);
16244 if (PyErr_Occurred()) SWIG_fail;
16245 }
16246 {
16247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16248 }
16249 return resultobj;
16250 fail:
16251 return NULL;
16252 }
16253
16254
16255 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16256 PyObject *resultobj;
16257 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16258 bool result;
16259 PyObject * obj0 = 0 ;
16260 char *kwnames[] = {
16261 (char *) "self", NULL
16262 };
16263
16264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16266 if (SWIG_arg_fail(1)) SWIG_fail;
16267 {
16268 PyThreadState* __tstate = wxPyBeginAllowThreads();
16269 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16270
16271 wxPyEndAllowThreads(__tstate);
16272 if (PyErr_Occurred()) SWIG_fail;
16273 }
16274 {
16275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16276 }
16277 return resultobj;
16278 fail:
16279 return NULL;
16280 }
16281
16282
16283 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16284 PyObject *resultobj;
16285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16286 bool result;
16287 PyObject * obj0 = 0 ;
16288 char *kwnames[] = {
16289 (char *) "self", NULL
16290 };
16291
16292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16294 if (SWIG_arg_fail(1)) SWIG_fail;
16295 {
16296 PyThreadState* __tstate = wxPyBeginAllowThreads();
16297 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16298
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 {
16303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16304 }
16305 return resultobj;
16306 fail:
16307 return NULL;
16308 }
16309
16310
16311 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16312 PyObject *resultobj;
16313 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16314 bool result;
16315 PyObject * obj0 = 0 ;
16316 char *kwnames[] = {
16317 (char *) "self", NULL
16318 };
16319
16320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16322 if (SWIG_arg_fail(1)) SWIG_fail;
16323 {
16324 PyThreadState* __tstate = wxPyBeginAllowThreads();
16325 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16326
16327 wxPyEndAllowThreads(__tstate);
16328 if (PyErr_Occurred()) SWIG_fail;
16329 }
16330 {
16331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16332 }
16333 return resultobj;
16334 fail:
16335 return NULL;
16336 }
16337
16338
16339 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16340 PyObject *resultobj;
16341 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16342 bool result;
16343 PyObject * obj0 = 0 ;
16344 char *kwnames[] = {
16345 (char *) "self", NULL
16346 };
16347
16348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16350 if (SWIG_arg_fail(1)) SWIG_fail;
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16354
16355 wxPyEndAllowThreads(__tstate);
16356 if (PyErr_Occurred()) SWIG_fail;
16357 }
16358 {
16359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16360 }
16361 return resultobj;
16362 fail:
16363 return NULL;
16364 }
16365
16366
16367 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16368 PyObject *resultobj;
16369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16370 bool result;
16371 PyObject * obj0 = 0 ;
16372 char *kwnames[] = {
16373 (char *) "self", NULL
16374 };
16375
16376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16378 if (SWIG_arg_fail(1)) SWIG_fail;
16379 {
16380 PyThreadState* __tstate = wxPyBeginAllowThreads();
16381 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16382
16383 wxPyEndAllowThreads(__tstate);
16384 if (PyErr_Occurred()) SWIG_fail;
16385 }
16386 {
16387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16388 }
16389 return resultobj;
16390 fail:
16391 return NULL;
16392 }
16393
16394
16395 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16396 PyObject *resultobj;
16397 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16398 bool result;
16399 PyObject * obj0 = 0 ;
16400 char *kwnames[] = {
16401 (char *) "self", NULL
16402 };
16403
16404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16406 if (SWIG_arg_fail(1)) SWIG_fail;
16407 {
16408 PyThreadState* __tstate = wxPyBeginAllowThreads();
16409 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16410
16411 wxPyEndAllowThreads(__tstate);
16412 if (PyErr_Occurred()) SWIG_fail;
16413 }
16414 {
16415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16416 }
16417 return resultobj;
16418 fail:
16419 return NULL;
16420 }
16421
16422
16423 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16424 PyObject *resultobj;
16425 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16426 bool result;
16427 PyObject * obj0 = 0 ;
16428 char *kwnames[] = {
16429 (char *) "self", NULL
16430 };
16431
16432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16434 if (SWIG_arg_fail(1)) SWIG_fail;
16435 {
16436 PyThreadState* __tstate = wxPyBeginAllowThreads();
16437 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16438
16439 wxPyEndAllowThreads(__tstate);
16440 if (PyErr_Occurred()) SWIG_fail;
16441 }
16442 {
16443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16444 }
16445 return resultobj;
16446 fail:
16447 return NULL;
16448 }
16449
16450
16451 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj;
16453 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16454 bool result;
16455 PyObject * obj0 = 0 ;
16456 char *kwnames[] = {
16457 (char *) "self", NULL
16458 };
16459
16460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16462 if (SWIG_arg_fail(1)) SWIG_fail;
16463 {
16464 PyThreadState* __tstate = wxPyBeginAllowThreads();
16465 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16466
16467 wxPyEndAllowThreads(__tstate);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 }
16470 {
16471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16472 }
16473 return resultobj;
16474 fail:
16475 return NULL;
16476 }
16477
16478
16479 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16480 PyObject *resultobj;
16481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16482 bool result;
16483 PyObject * obj0 = 0 ;
16484 char *kwnames[] = {
16485 (char *) "self", NULL
16486 };
16487
16488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16490 if (SWIG_arg_fail(1)) SWIG_fail;
16491 {
16492 PyThreadState* __tstate = wxPyBeginAllowThreads();
16493 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16494
16495 wxPyEndAllowThreads(__tstate);
16496 if (PyErr_Occurred()) SWIG_fail;
16497 }
16498 {
16499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16500 }
16501 return resultobj;
16502 fail:
16503 return NULL;
16504 }
16505
16506
16507 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16508 PyObject *resultobj;
16509 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16510 bool result;
16511 PyObject * obj0 = 0 ;
16512 char *kwnames[] = {
16513 (char *) "self", NULL
16514 };
16515
16516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16518 if (SWIG_arg_fail(1)) SWIG_fail;
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16522
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 {
16527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16528 }
16529 return resultobj;
16530 fail:
16531 return NULL;
16532 }
16533
16534
16535 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16536 PyObject *resultobj;
16537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16538 bool result;
16539 PyObject * obj0 = 0 ;
16540 char *kwnames[] = {
16541 (char *) "self", NULL
16542 };
16543
16544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16546 if (SWIG_arg_fail(1)) SWIG_fail;
16547 {
16548 PyThreadState* __tstate = wxPyBeginAllowThreads();
16549 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16550
16551 wxPyEndAllowThreads(__tstate);
16552 if (PyErr_Occurred()) SWIG_fail;
16553 }
16554 {
16555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16556 }
16557 return resultobj;
16558 fail:
16559 return NULL;
16560 }
16561
16562
16563 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16564 PyObject *resultobj;
16565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16566 bool result;
16567 PyObject * obj0 = 0 ;
16568 char *kwnames[] = {
16569 (char *) "self", NULL
16570 };
16571
16572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16574 if (SWIG_arg_fail(1)) SWIG_fail;
16575 {
16576 PyThreadState* __tstate = wxPyBeginAllowThreads();
16577 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16578
16579 wxPyEndAllowThreads(__tstate);
16580 if (PyErr_Occurred()) SWIG_fail;
16581 }
16582 {
16583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16584 }
16585 return resultobj;
16586 fail:
16587 return NULL;
16588 }
16589
16590
16591 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj;
16593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16594 bool result;
16595 PyObject * obj0 = 0 ;
16596 char *kwnames[] = {
16597 (char *) "self", NULL
16598 };
16599
16600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16602 if (SWIG_arg_fail(1)) SWIG_fail;
16603 {
16604 PyThreadState* __tstate = wxPyBeginAllowThreads();
16605 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16606
16607 wxPyEndAllowThreads(__tstate);
16608 if (PyErr_Occurred()) SWIG_fail;
16609 }
16610 {
16611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16612 }
16613 return resultobj;
16614 fail:
16615 return NULL;
16616 }
16617
16618
16619 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16620 PyObject *resultobj;
16621 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16622 bool result;
16623 PyObject * obj0 = 0 ;
16624 char *kwnames[] = {
16625 (char *) "self", NULL
16626 };
16627
16628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16630 if (SWIG_arg_fail(1)) SWIG_fail;
16631 {
16632 PyThreadState* __tstate = wxPyBeginAllowThreads();
16633 result = (bool)(arg1)->LeftIsDown();
16634
16635 wxPyEndAllowThreads(__tstate);
16636 if (PyErr_Occurred()) SWIG_fail;
16637 }
16638 {
16639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16640 }
16641 return resultobj;
16642 fail:
16643 return NULL;
16644 }
16645
16646
16647 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16648 PyObject *resultobj;
16649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16650 bool result;
16651 PyObject * obj0 = 0 ;
16652 char *kwnames[] = {
16653 (char *) "self", NULL
16654 };
16655
16656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16658 if (SWIG_arg_fail(1)) SWIG_fail;
16659 {
16660 PyThreadState* __tstate = wxPyBeginAllowThreads();
16661 result = (bool)(arg1)->MiddleIsDown();
16662
16663 wxPyEndAllowThreads(__tstate);
16664 if (PyErr_Occurred()) SWIG_fail;
16665 }
16666 {
16667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16668 }
16669 return resultobj;
16670 fail:
16671 return NULL;
16672 }
16673
16674
16675 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16676 PyObject *resultobj;
16677 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16678 bool result;
16679 PyObject * obj0 = 0 ;
16680 char *kwnames[] = {
16681 (char *) "self", NULL
16682 };
16683
16684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16686 if (SWIG_arg_fail(1)) SWIG_fail;
16687 {
16688 PyThreadState* __tstate = wxPyBeginAllowThreads();
16689 result = (bool)(arg1)->RightIsDown();
16690
16691 wxPyEndAllowThreads(__tstate);
16692 if (PyErr_Occurred()) SWIG_fail;
16693 }
16694 {
16695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16696 }
16697 return resultobj;
16698 fail:
16699 return NULL;
16700 }
16701
16702
16703 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16704 PyObject *resultobj;
16705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16706 bool result;
16707 PyObject * obj0 = 0 ;
16708 char *kwnames[] = {
16709 (char *) "self", NULL
16710 };
16711
16712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16714 if (SWIG_arg_fail(1)) SWIG_fail;
16715 {
16716 PyThreadState* __tstate = wxPyBeginAllowThreads();
16717 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16718
16719 wxPyEndAllowThreads(__tstate);
16720 if (PyErr_Occurred()) SWIG_fail;
16721 }
16722 {
16723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16724 }
16725 return resultobj;
16726 fail:
16727 return NULL;
16728 }
16729
16730
16731 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16732 PyObject *resultobj;
16733 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16734 bool result;
16735 PyObject * obj0 = 0 ;
16736 char *kwnames[] = {
16737 (char *) "self", NULL
16738 };
16739
16740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16742 if (SWIG_arg_fail(1)) SWIG_fail;
16743 {
16744 PyThreadState* __tstate = wxPyBeginAllowThreads();
16745 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16746
16747 wxPyEndAllowThreads(__tstate);
16748 if (PyErr_Occurred()) SWIG_fail;
16749 }
16750 {
16751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16752 }
16753 return resultobj;
16754 fail:
16755 return NULL;
16756 }
16757
16758
16759 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16760 PyObject *resultobj;
16761 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16762 bool result;
16763 PyObject * obj0 = 0 ;
16764 char *kwnames[] = {
16765 (char *) "self", NULL
16766 };
16767
16768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16770 if (SWIG_arg_fail(1)) SWIG_fail;
16771 {
16772 PyThreadState* __tstate = wxPyBeginAllowThreads();
16773 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16774
16775 wxPyEndAllowThreads(__tstate);
16776 if (PyErr_Occurred()) SWIG_fail;
16777 }
16778 {
16779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16780 }
16781 return resultobj;
16782 fail:
16783 return NULL;
16784 }
16785
16786
16787 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16788 PyObject *resultobj;
16789 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16790 bool result;
16791 PyObject * obj0 = 0 ;
16792 char *kwnames[] = {
16793 (char *) "self", NULL
16794 };
16795
16796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16798 if (SWIG_arg_fail(1)) SWIG_fail;
16799 {
16800 PyThreadState* __tstate = wxPyBeginAllowThreads();
16801 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16802
16803 wxPyEndAllowThreads(__tstate);
16804 if (PyErr_Occurred()) SWIG_fail;
16805 }
16806 {
16807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16808 }
16809 return resultobj;
16810 fail:
16811 return NULL;
16812 }
16813
16814
16815 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16816 PyObject *resultobj;
16817 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16818 wxPoint result;
16819 PyObject * obj0 = 0 ;
16820 char *kwnames[] = {
16821 (char *) "self", NULL
16822 };
16823
16824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16826 if (SWIG_arg_fail(1)) SWIG_fail;
16827 {
16828 PyThreadState* __tstate = wxPyBeginAllowThreads();
16829 result = (arg1)->GetPosition();
16830
16831 wxPyEndAllowThreads(__tstate);
16832 if (PyErr_Occurred()) SWIG_fail;
16833 }
16834 {
16835 wxPoint * resultptr;
16836 resultptr = new wxPoint((wxPoint &)(result));
16837 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16838 }
16839 return resultobj;
16840 fail:
16841 return NULL;
16842 }
16843
16844
16845 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16846 PyObject *resultobj;
16847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16848 long *arg2 = (long *) 0 ;
16849 long *arg3 = (long *) 0 ;
16850 long temp2 ;
16851 int res2 = 0 ;
16852 long temp3 ;
16853 int res3 = 0 ;
16854 PyObject * obj0 = 0 ;
16855 char *kwnames[] = {
16856 (char *) "self", NULL
16857 };
16858
16859 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16860 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16863 if (SWIG_arg_fail(1)) SWIG_fail;
16864 {
16865 PyThreadState* __tstate = wxPyBeginAllowThreads();
16866 (arg1)->GetPosition(arg2,arg3);
16867
16868 wxPyEndAllowThreads(__tstate);
16869 if (PyErr_Occurred()) SWIG_fail;
16870 }
16871 Py_INCREF(Py_None); resultobj = Py_None;
16872 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16873 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16874 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16875 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16876 return resultobj;
16877 fail:
16878 return NULL;
16879 }
16880
16881
16882 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16883 PyObject *resultobj;
16884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16885 wxDC *arg2 = 0 ;
16886 wxPoint result;
16887 PyObject * obj0 = 0 ;
16888 PyObject * obj1 = 0 ;
16889 char *kwnames[] = {
16890 (char *) "self",(char *) "dc", NULL
16891 };
16892
16893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16895 if (SWIG_arg_fail(1)) SWIG_fail;
16896 {
16897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16898 if (SWIG_arg_fail(2)) SWIG_fail;
16899 if (arg2 == NULL) {
16900 SWIG_null_ref("wxDC");
16901 }
16902 if (SWIG_arg_fail(2)) SWIG_fail;
16903 }
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16907
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 {
16912 wxPoint * resultptr;
16913 resultptr = new wxPoint((wxPoint &)(result));
16914 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16915 }
16916 return resultobj;
16917 fail:
16918 return NULL;
16919 }
16920
16921
16922 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16923 PyObject *resultobj;
16924 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16925 int result;
16926 PyObject * obj0 = 0 ;
16927 char *kwnames[] = {
16928 (char *) "self", NULL
16929 };
16930
16931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16933 if (SWIG_arg_fail(1)) SWIG_fail;
16934 {
16935 PyThreadState* __tstate = wxPyBeginAllowThreads();
16936 result = (int)((wxMouseEvent const *)arg1)->GetX();
16937
16938 wxPyEndAllowThreads(__tstate);
16939 if (PyErr_Occurred()) SWIG_fail;
16940 }
16941 {
16942 resultobj = SWIG_From_int((int)(result));
16943 }
16944 return resultobj;
16945 fail:
16946 return NULL;
16947 }
16948
16949
16950 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16951 PyObject *resultobj;
16952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16953 int result;
16954 PyObject * obj0 = 0 ;
16955 char *kwnames[] = {
16956 (char *) "self", NULL
16957 };
16958
16959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16961 if (SWIG_arg_fail(1)) SWIG_fail;
16962 {
16963 PyThreadState* __tstate = wxPyBeginAllowThreads();
16964 result = (int)((wxMouseEvent const *)arg1)->GetY();
16965
16966 wxPyEndAllowThreads(__tstate);
16967 if (PyErr_Occurred()) SWIG_fail;
16968 }
16969 {
16970 resultobj = SWIG_From_int((int)(result));
16971 }
16972 return resultobj;
16973 fail:
16974 return NULL;
16975 }
16976
16977
16978 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16979 PyObject *resultobj;
16980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16981 int result;
16982 PyObject * obj0 = 0 ;
16983 char *kwnames[] = {
16984 (char *) "self", NULL
16985 };
16986
16987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16989 if (SWIG_arg_fail(1)) SWIG_fail;
16990 {
16991 PyThreadState* __tstate = wxPyBeginAllowThreads();
16992 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16993
16994 wxPyEndAllowThreads(__tstate);
16995 if (PyErr_Occurred()) SWIG_fail;
16996 }
16997 {
16998 resultobj = SWIG_From_int((int)(result));
16999 }
17000 return resultobj;
17001 fail:
17002 return NULL;
17003 }
17004
17005
17006 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17007 PyObject *resultobj;
17008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17009 int result;
17010 PyObject * obj0 = 0 ;
17011 char *kwnames[] = {
17012 (char *) "self", NULL
17013 };
17014
17015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17017 if (SWIG_arg_fail(1)) SWIG_fail;
17018 {
17019 PyThreadState* __tstate = wxPyBeginAllowThreads();
17020 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17021
17022 wxPyEndAllowThreads(__tstate);
17023 if (PyErr_Occurred()) SWIG_fail;
17024 }
17025 {
17026 resultobj = SWIG_From_int((int)(result));
17027 }
17028 return resultobj;
17029 fail:
17030 return NULL;
17031 }
17032
17033
17034 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17035 PyObject *resultobj;
17036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17037 int result;
17038 PyObject * obj0 = 0 ;
17039 char *kwnames[] = {
17040 (char *) "self", NULL
17041 };
17042
17043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17045 if (SWIG_arg_fail(1)) SWIG_fail;
17046 {
17047 PyThreadState* __tstate = wxPyBeginAllowThreads();
17048 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17049
17050 wxPyEndAllowThreads(__tstate);
17051 if (PyErr_Occurred()) SWIG_fail;
17052 }
17053 {
17054 resultobj = SWIG_From_int((int)(result));
17055 }
17056 return resultobj;
17057 fail:
17058 return NULL;
17059 }
17060
17061
17062 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17063 PyObject *resultobj;
17064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17065 bool result;
17066 PyObject * obj0 = 0 ;
17067 char *kwnames[] = {
17068 (char *) "self", NULL
17069 };
17070
17071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17073 if (SWIG_arg_fail(1)) SWIG_fail;
17074 {
17075 PyThreadState* __tstate = wxPyBeginAllowThreads();
17076 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17077
17078 wxPyEndAllowThreads(__tstate);
17079 if (PyErr_Occurred()) SWIG_fail;
17080 }
17081 {
17082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17083 }
17084 return resultobj;
17085 fail:
17086 return NULL;
17087 }
17088
17089
17090 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17091 PyObject *resultobj;
17092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17093 int arg2 ;
17094 PyObject * obj0 = 0 ;
17095 PyObject * obj1 = 0 ;
17096 char *kwnames[] = {
17097 (char *) "self",(char *) "m_x", NULL
17098 };
17099
17100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17102 if (SWIG_arg_fail(1)) SWIG_fail;
17103 {
17104 arg2 = (int)(SWIG_As_int(obj1));
17105 if (SWIG_arg_fail(2)) SWIG_fail;
17106 }
17107 if (arg1) (arg1)->m_x = arg2;
17108
17109 Py_INCREF(Py_None); resultobj = Py_None;
17110 return resultobj;
17111 fail:
17112 return NULL;
17113 }
17114
17115
17116 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17117 PyObject *resultobj;
17118 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17119 int result;
17120 PyObject * obj0 = 0 ;
17121 char *kwnames[] = {
17122 (char *) "self", NULL
17123 };
17124
17125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) 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 result = (int) ((arg1)->m_x);
17129
17130 {
17131 resultobj = SWIG_From_int((int)(result));
17132 }
17133 return resultobj;
17134 fail:
17135 return NULL;
17136 }
17137
17138
17139 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17140 PyObject *resultobj;
17141 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17142 int arg2 ;
17143 PyObject * obj0 = 0 ;
17144 PyObject * obj1 = 0 ;
17145 char *kwnames[] = {
17146 (char *) "self",(char *) "m_y", NULL
17147 };
17148
17149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17151 if (SWIG_arg_fail(1)) SWIG_fail;
17152 {
17153 arg2 = (int)(SWIG_As_int(obj1));
17154 if (SWIG_arg_fail(2)) SWIG_fail;
17155 }
17156 if (arg1) (arg1)->m_y = arg2;
17157
17158 Py_INCREF(Py_None); resultobj = Py_None;
17159 return resultobj;
17160 fail:
17161 return NULL;
17162 }
17163
17164
17165 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17166 PyObject *resultobj;
17167 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17168 int result;
17169 PyObject * obj0 = 0 ;
17170 char *kwnames[] = {
17171 (char *) "self", NULL
17172 };
17173
17174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17176 if (SWIG_arg_fail(1)) SWIG_fail;
17177 result = (int) ((arg1)->m_y);
17178
17179 {
17180 resultobj = SWIG_From_int((int)(result));
17181 }
17182 return resultobj;
17183 fail:
17184 return NULL;
17185 }
17186
17187
17188 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17189 PyObject *resultobj;
17190 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17191 bool arg2 ;
17192 PyObject * obj0 = 0 ;
17193 PyObject * obj1 = 0 ;
17194 char *kwnames[] = {
17195 (char *) "self",(char *) "m_leftDown", NULL
17196 };
17197
17198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17200 if (SWIG_arg_fail(1)) SWIG_fail;
17201 {
17202 arg2 = (bool)(SWIG_As_bool(obj1));
17203 if (SWIG_arg_fail(2)) SWIG_fail;
17204 }
17205 if (arg1) (arg1)->m_leftDown = arg2;
17206
17207 Py_INCREF(Py_None); resultobj = Py_None;
17208 return resultobj;
17209 fail:
17210 return NULL;
17211 }
17212
17213
17214 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17215 PyObject *resultobj;
17216 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17217 bool result;
17218 PyObject * obj0 = 0 ;
17219 char *kwnames[] = {
17220 (char *) "self", NULL
17221 };
17222
17223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17225 if (SWIG_arg_fail(1)) SWIG_fail;
17226 result = (bool) ((arg1)->m_leftDown);
17227
17228 {
17229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17230 }
17231 return resultobj;
17232 fail:
17233 return NULL;
17234 }
17235
17236
17237 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17238 PyObject *resultobj;
17239 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17240 bool arg2 ;
17241 PyObject * obj0 = 0 ;
17242 PyObject * obj1 = 0 ;
17243 char *kwnames[] = {
17244 (char *) "self",(char *) "m_middleDown", NULL
17245 };
17246
17247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17249 if (SWIG_arg_fail(1)) SWIG_fail;
17250 {
17251 arg2 = (bool)(SWIG_As_bool(obj1));
17252 if (SWIG_arg_fail(2)) SWIG_fail;
17253 }
17254 if (arg1) (arg1)->m_middleDown = arg2;
17255
17256 Py_INCREF(Py_None); resultobj = Py_None;
17257 return resultobj;
17258 fail:
17259 return NULL;
17260 }
17261
17262
17263 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17264 PyObject *resultobj;
17265 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17266 bool result;
17267 PyObject * obj0 = 0 ;
17268 char *kwnames[] = {
17269 (char *) "self", NULL
17270 };
17271
17272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17274 if (SWIG_arg_fail(1)) SWIG_fail;
17275 result = (bool) ((arg1)->m_middleDown);
17276
17277 {
17278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17279 }
17280 return resultobj;
17281 fail:
17282 return NULL;
17283 }
17284
17285
17286 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17287 PyObject *resultobj;
17288 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17289 bool arg2 ;
17290 PyObject * obj0 = 0 ;
17291 PyObject * obj1 = 0 ;
17292 char *kwnames[] = {
17293 (char *) "self",(char *) "m_rightDown", NULL
17294 };
17295
17296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17298 if (SWIG_arg_fail(1)) SWIG_fail;
17299 {
17300 arg2 = (bool)(SWIG_As_bool(obj1));
17301 if (SWIG_arg_fail(2)) SWIG_fail;
17302 }
17303 if (arg1) (arg1)->m_rightDown = arg2;
17304
17305 Py_INCREF(Py_None); resultobj = Py_None;
17306 return resultobj;
17307 fail:
17308 return NULL;
17309 }
17310
17311
17312 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17313 PyObject *resultobj;
17314 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17315 bool result;
17316 PyObject * obj0 = 0 ;
17317 char *kwnames[] = {
17318 (char *) "self", NULL
17319 };
17320
17321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17323 if (SWIG_arg_fail(1)) SWIG_fail;
17324 result = (bool) ((arg1)->m_rightDown);
17325
17326 {
17327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17328 }
17329 return resultobj;
17330 fail:
17331 return NULL;
17332 }
17333
17334
17335 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17336 PyObject *resultobj;
17337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17338 bool arg2 ;
17339 PyObject * obj0 = 0 ;
17340 PyObject * obj1 = 0 ;
17341 char *kwnames[] = {
17342 (char *) "self",(char *) "m_controlDown", NULL
17343 };
17344
17345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17347 if (SWIG_arg_fail(1)) SWIG_fail;
17348 {
17349 arg2 = (bool)(SWIG_As_bool(obj1));
17350 if (SWIG_arg_fail(2)) SWIG_fail;
17351 }
17352 if (arg1) (arg1)->m_controlDown = arg2;
17353
17354 Py_INCREF(Py_None); resultobj = Py_None;
17355 return resultobj;
17356 fail:
17357 return NULL;
17358 }
17359
17360
17361 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17362 PyObject *resultobj;
17363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17364 bool result;
17365 PyObject * obj0 = 0 ;
17366 char *kwnames[] = {
17367 (char *) "self", NULL
17368 };
17369
17370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17372 if (SWIG_arg_fail(1)) SWIG_fail;
17373 result = (bool) ((arg1)->m_controlDown);
17374
17375 {
17376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17377 }
17378 return resultobj;
17379 fail:
17380 return NULL;
17381 }
17382
17383
17384 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17385 PyObject *resultobj;
17386 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17387 bool arg2 ;
17388 PyObject * obj0 = 0 ;
17389 PyObject * obj1 = 0 ;
17390 char *kwnames[] = {
17391 (char *) "self",(char *) "m_shiftDown", NULL
17392 };
17393
17394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17396 if (SWIG_arg_fail(1)) SWIG_fail;
17397 {
17398 arg2 = (bool)(SWIG_As_bool(obj1));
17399 if (SWIG_arg_fail(2)) SWIG_fail;
17400 }
17401 if (arg1) (arg1)->m_shiftDown = arg2;
17402
17403 Py_INCREF(Py_None); resultobj = Py_None;
17404 return resultobj;
17405 fail:
17406 return NULL;
17407 }
17408
17409
17410 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17411 PyObject *resultobj;
17412 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17413 bool result;
17414 PyObject * obj0 = 0 ;
17415 char *kwnames[] = {
17416 (char *) "self", NULL
17417 };
17418
17419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17421 if (SWIG_arg_fail(1)) SWIG_fail;
17422 result = (bool) ((arg1)->m_shiftDown);
17423
17424 {
17425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17426 }
17427 return resultobj;
17428 fail:
17429 return NULL;
17430 }
17431
17432
17433 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17434 PyObject *resultobj;
17435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17436 bool arg2 ;
17437 PyObject * obj0 = 0 ;
17438 PyObject * obj1 = 0 ;
17439 char *kwnames[] = {
17440 (char *) "self",(char *) "m_altDown", NULL
17441 };
17442
17443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17445 if (SWIG_arg_fail(1)) SWIG_fail;
17446 {
17447 arg2 = (bool)(SWIG_As_bool(obj1));
17448 if (SWIG_arg_fail(2)) SWIG_fail;
17449 }
17450 if (arg1) (arg1)->m_altDown = arg2;
17451
17452 Py_INCREF(Py_None); resultobj = Py_None;
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17460 PyObject *resultobj;
17461 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17462 bool result;
17463 PyObject * obj0 = 0 ;
17464 char *kwnames[] = {
17465 (char *) "self", NULL
17466 };
17467
17468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17470 if (SWIG_arg_fail(1)) SWIG_fail;
17471 result = (bool) ((arg1)->m_altDown);
17472
17473 {
17474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17475 }
17476 return resultobj;
17477 fail:
17478 return NULL;
17479 }
17480
17481
17482 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17483 PyObject *resultobj;
17484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17485 bool arg2 ;
17486 PyObject * obj0 = 0 ;
17487 PyObject * obj1 = 0 ;
17488 char *kwnames[] = {
17489 (char *) "self",(char *) "m_metaDown", NULL
17490 };
17491
17492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17494 if (SWIG_arg_fail(1)) SWIG_fail;
17495 {
17496 arg2 = (bool)(SWIG_As_bool(obj1));
17497 if (SWIG_arg_fail(2)) SWIG_fail;
17498 }
17499 if (arg1) (arg1)->m_metaDown = arg2;
17500
17501 Py_INCREF(Py_None); resultobj = Py_None;
17502 return resultobj;
17503 fail:
17504 return NULL;
17505 }
17506
17507
17508 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17509 PyObject *resultobj;
17510 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17511 bool result;
17512 PyObject * obj0 = 0 ;
17513 char *kwnames[] = {
17514 (char *) "self", NULL
17515 };
17516
17517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17519 if (SWIG_arg_fail(1)) SWIG_fail;
17520 result = (bool) ((arg1)->m_metaDown);
17521
17522 {
17523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17524 }
17525 return resultobj;
17526 fail:
17527 return NULL;
17528 }
17529
17530
17531 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17532 PyObject *resultobj;
17533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17534 int arg2 ;
17535 PyObject * obj0 = 0 ;
17536 PyObject * obj1 = 0 ;
17537 char *kwnames[] = {
17538 (char *) "self",(char *) "m_wheelRotation", NULL
17539 };
17540
17541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17543 if (SWIG_arg_fail(1)) SWIG_fail;
17544 {
17545 arg2 = (int)(SWIG_As_int(obj1));
17546 if (SWIG_arg_fail(2)) SWIG_fail;
17547 }
17548 if (arg1) (arg1)->m_wheelRotation = arg2;
17549
17550 Py_INCREF(Py_None); resultobj = Py_None;
17551 return resultobj;
17552 fail:
17553 return NULL;
17554 }
17555
17556
17557 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17558 PyObject *resultobj;
17559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17560 int result;
17561 PyObject * obj0 = 0 ;
17562 char *kwnames[] = {
17563 (char *) "self", NULL
17564 };
17565
17566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17568 if (SWIG_arg_fail(1)) SWIG_fail;
17569 result = (int) ((arg1)->m_wheelRotation);
17570
17571 {
17572 resultobj = SWIG_From_int((int)(result));
17573 }
17574 return resultobj;
17575 fail:
17576 return NULL;
17577 }
17578
17579
17580 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17581 PyObject *resultobj;
17582 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17583 int arg2 ;
17584 PyObject * obj0 = 0 ;
17585 PyObject * obj1 = 0 ;
17586 char *kwnames[] = {
17587 (char *) "self",(char *) "m_wheelDelta", NULL
17588 };
17589
17590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17592 if (SWIG_arg_fail(1)) SWIG_fail;
17593 {
17594 arg2 = (int)(SWIG_As_int(obj1));
17595 if (SWIG_arg_fail(2)) SWIG_fail;
17596 }
17597 if (arg1) (arg1)->m_wheelDelta = arg2;
17598
17599 Py_INCREF(Py_None); resultobj = Py_None;
17600 return resultobj;
17601 fail:
17602 return NULL;
17603 }
17604
17605
17606 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17607 PyObject *resultobj;
17608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17609 int result;
17610 PyObject * obj0 = 0 ;
17611 char *kwnames[] = {
17612 (char *) "self", NULL
17613 };
17614
17615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17617 if (SWIG_arg_fail(1)) SWIG_fail;
17618 result = (int) ((arg1)->m_wheelDelta);
17619
17620 {
17621 resultobj = SWIG_From_int((int)(result));
17622 }
17623 return resultobj;
17624 fail:
17625 return NULL;
17626 }
17627
17628
17629 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17630 PyObject *resultobj;
17631 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17632 int arg2 ;
17633 PyObject * obj0 = 0 ;
17634 PyObject * obj1 = 0 ;
17635 char *kwnames[] = {
17636 (char *) "self",(char *) "m_linesPerAction", NULL
17637 };
17638
17639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17641 if (SWIG_arg_fail(1)) SWIG_fail;
17642 {
17643 arg2 = (int)(SWIG_As_int(obj1));
17644 if (SWIG_arg_fail(2)) SWIG_fail;
17645 }
17646 if (arg1) (arg1)->m_linesPerAction = arg2;
17647
17648 Py_INCREF(Py_None); resultobj = Py_None;
17649 return resultobj;
17650 fail:
17651 return NULL;
17652 }
17653
17654
17655 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17656 PyObject *resultobj;
17657 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17658 int result;
17659 PyObject * obj0 = 0 ;
17660 char *kwnames[] = {
17661 (char *) "self", NULL
17662 };
17663
17664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17666 if (SWIG_arg_fail(1)) SWIG_fail;
17667 result = (int) ((arg1)->m_linesPerAction);
17668
17669 {
17670 resultobj = SWIG_From_int((int)(result));
17671 }
17672 return resultobj;
17673 fail:
17674 return NULL;
17675 }
17676
17677
17678 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17679 PyObject *obj;
17680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17681 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17682 Py_INCREF(obj);
17683 return Py_BuildValue((char *)"");
17684 }
17685 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17686 PyObject *resultobj;
17687 int arg1 = (int) 0 ;
17688 int arg2 = (int) 0 ;
17689 wxSetCursorEvent *result;
17690 PyObject * obj0 = 0 ;
17691 PyObject * obj1 = 0 ;
17692 char *kwnames[] = {
17693 (char *) "x",(char *) "y", NULL
17694 };
17695
17696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17697 if (obj0) {
17698 {
17699 arg1 = (int)(SWIG_As_int(obj0));
17700 if (SWIG_arg_fail(1)) SWIG_fail;
17701 }
17702 }
17703 if (obj1) {
17704 {
17705 arg2 = (int)(SWIG_As_int(obj1));
17706 if (SWIG_arg_fail(2)) SWIG_fail;
17707 }
17708 }
17709 {
17710 PyThreadState* __tstate = wxPyBeginAllowThreads();
17711 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17712
17713 wxPyEndAllowThreads(__tstate);
17714 if (PyErr_Occurred()) SWIG_fail;
17715 }
17716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17717 return resultobj;
17718 fail:
17719 return NULL;
17720 }
17721
17722
17723 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17724 PyObject *resultobj;
17725 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17726 int result;
17727 PyObject * obj0 = 0 ;
17728 char *kwnames[] = {
17729 (char *) "self", NULL
17730 };
17731
17732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17734 if (SWIG_arg_fail(1)) SWIG_fail;
17735 {
17736 PyThreadState* __tstate = wxPyBeginAllowThreads();
17737 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17738
17739 wxPyEndAllowThreads(__tstate);
17740 if (PyErr_Occurred()) SWIG_fail;
17741 }
17742 {
17743 resultobj = SWIG_From_int((int)(result));
17744 }
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17752 PyObject *resultobj;
17753 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17754 int result;
17755 PyObject * obj0 = 0 ;
17756 char *kwnames[] = {
17757 (char *) "self", NULL
17758 };
17759
17760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17762 if (SWIG_arg_fail(1)) SWIG_fail;
17763 {
17764 PyThreadState* __tstate = wxPyBeginAllowThreads();
17765 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17766
17767 wxPyEndAllowThreads(__tstate);
17768 if (PyErr_Occurred()) SWIG_fail;
17769 }
17770 {
17771 resultobj = SWIG_From_int((int)(result));
17772 }
17773 return resultobj;
17774 fail:
17775 return NULL;
17776 }
17777
17778
17779 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17780 PyObject *resultobj;
17781 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17782 wxCursor *arg2 = 0 ;
17783 PyObject * obj0 = 0 ;
17784 PyObject * obj1 = 0 ;
17785 char *kwnames[] = {
17786 (char *) "self",(char *) "cursor", NULL
17787 };
17788
17789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17791 if (SWIG_arg_fail(1)) SWIG_fail;
17792 {
17793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17794 if (SWIG_arg_fail(2)) SWIG_fail;
17795 if (arg2 == NULL) {
17796 SWIG_null_ref("wxCursor");
17797 }
17798 if (SWIG_arg_fail(2)) SWIG_fail;
17799 }
17800 {
17801 PyThreadState* __tstate = wxPyBeginAllowThreads();
17802 (arg1)->SetCursor((wxCursor const &)*arg2);
17803
17804 wxPyEndAllowThreads(__tstate);
17805 if (PyErr_Occurred()) SWIG_fail;
17806 }
17807 Py_INCREF(Py_None); resultobj = Py_None;
17808 return resultobj;
17809 fail:
17810 return NULL;
17811 }
17812
17813
17814 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17815 PyObject *resultobj;
17816 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17817 wxCursor *result;
17818 PyObject * obj0 = 0 ;
17819 char *kwnames[] = {
17820 (char *) "self", NULL
17821 };
17822
17823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17825 if (SWIG_arg_fail(1)) SWIG_fail;
17826 {
17827 PyThreadState* __tstate = wxPyBeginAllowThreads();
17828 {
17829 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17830 result = (wxCursor *) &_result_ref;
17831 }
17832
17833 wxPyEndAllowThreads(__tstate);
17834 if (PyErr_Occurred()) SWIG_fail;
17835 }
17836 {
17837 wxCursor* resultptr = new wxCursor(*result);
17838 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17839 }
17840 return resultobj;
17841 fail:
17842 return NULL;
17843 }
17844
17845
17846 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17847 PyObject *resultobj;
17848 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17849 bool result;
17850 PyObject * obj0 = 0 ;
17851 char *kwnames[] = {
17852 (char *) "self", NULL
17853 };
17854
17855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17857 if (SWIG_arg_fail(1)) SWIG_fail;
17858 {
17859 PyThreadState* __tstate = wxPyBeginAllowThreads();
17860 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17861
17862 wxPyEndAllowThreads(__tstate);
17863 if (PyErr_Occurred()) SWIG_fail;
17864 }
17865 {
17866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17867 }
17868 return resultobj;
17869 fail:
17870 return NULL;
17871 }
17872
17873
17874 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17875 PyObject *obj;
17876 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17877 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17878 Py_INCREF(obj);
17879 return Py_BuildValue((char *)"");
17880 }
17881 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17882 PyObject *resultobj;
17883 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17884 wxKeyEvent *result;
17885 PyObject * obj0 = 0 ;
17886 char *kwnames[] = {
17887 (char *) "keyType", NULL
17888 };
17889
17890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17891 if (obj0) {
17892 {
17893 arg1 = (wxEventType)(SWIG_As_int(obj0));
17894 if (SWIG_arg_fail(1)) SWIG_fail;
17895 }
17896 }
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17900
17901 wxPyEndAllowThreads(__tstate);
17902 if (PyErr_Occurred()) SWIG_fail;
17903 }
17904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17905 return resultobj;
17906 fail:
17907 return NULL;
17908 }
17909
17910
17911 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17912 PyObject *resultobj;
17913 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17914 bool result;
17915 PyObject * obj0 = 0 ;
17916 char *kwnames[] = {
17917 (char *) "self", NULL
17918 };
17919
17920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17922 if (SWIG_arg_fail(1)) SWIG_fail;
17923 {
17924 PyThreadState* __tstate = wxPyBeginAllowThreads();
17925 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17926
17927 wxPyEndAllowThreads(__tstate);
17928 if (PyErr_Occurred()) SWIG_fail;
17929 }
17930 {
17931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17932 }
17933 return resultobj;
17934 fail:
17935 return NULL;
17936 }
17937
17938
17939 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17940 PyObject *resultobj;
17941 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17942 bool result;
17943 PyObject * obj0 = 0 ;
17944 char *kwnames[] = {
17945 (char *) "self", NULL
17946 };
17947
17948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17950 if (SWIG_arg_fail(1)) SWIG_fail;
17951 {
17952 PyThreadState* __tstate = wxPyBeginAllowThreads();
17953 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17954
17955 wxPyEndAllowThreads(__tstate);
17956 if (PyErr_Occurred()) SWIG_fail;
17957 }
17958 {
17959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17960 }
17961 return resultobj;
17962 fail:
17963 return NULL;
17964 }
17965
17966
17967 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17968 PyObject *resultobj;
17969 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17970 bool result;
17971 PyObject * obj0 = 0 ;
17972 char *kwnames[] = {
17973 (char *) "self", NULL
17974 };
17975
17976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17978 if (SWIG_arg_fail(1)) SWIG_fail;
17979 {
17980 PyThreadState* __tstate = wxPyBeginAllowThreads();
17981 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17982
17983 wxPyEndAllowThreads(__tstate);
17984 if (PyErr_Occurred()) SWIG_fail;
17985 }
17986 {
17987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17988 }
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17996 PyObject *resultobj;
17997 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17998 bool result;
17999 PyObject * obj0 = 0 ;
18000 char *kwnames[] = {
18001 (char *) "self", NULL
18002 };
18003
18004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18006 if (SWIG_arg_fail(1)) SWIG_fail;
18007 {
18008 PyThreadState* __tstate = wxPyBeginAllowThreads();
18009 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18010
18011 wxPyEndAllowThreads(__tstate);
18012 if (PyErr_Occurred()) SWIG_fail;
18013 }
18014 {
18015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18016 }
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18024 PyObject *resultobj;
18025 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18026 bool result;
18027 PyObject * obj0 = 0 ;
18028 char *kwnames[] = {
18029 (char *) "self", NULL
18030 };
18031
18032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18034 if (SWIG_arg_fail(1)) SWIG_fail;
18035 {
18036 PyThreadState* __tstate = wxPyBeginAllowThreads();
18037 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18038
18039 wxPyEndAllowThreads(__tstate);
18040 if (PyErr_Occurred()) SWIG_fail;
18041 }
18042 {
18043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18044 }
18045 return resultobj;
18046 fail:
18047 return NULL;
18048 }
18049
18050
18051 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18052 PyObject *resultobj;
18053 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18054 bool result;
18055 PyObject * obj0 = 0 ;
18056 char *kwnames[] = {
18057 (char *) "self", NULL
18058 };
18059
18060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18062 if (SWIG_arg_fail(1)) SWIG_fail;
18063 {
18064 PyThreadState* __tstate = wxPyBeginAllowThreads();
18065 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18066
18067 wxPyEndAllowThreads(__tstate);
18068 if (PyErr_Occurred()) SWIG_fail;
18069 }
18070 {
18071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18072 }
18073 return resultobj;
18074 fail:
18075 return NULL;
18076 }
18077
18078
18079 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18080 PyObject *resultobj;
18081 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18082 int result;
18083 PyObject * obj0 = 0 ;
18084 char *kwnames[] = {
18085 (char *) "self", NULL
18086 };
18087
18088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18090 if (SWIG_arg_fail(1)) SWIG_fail;
18091 {
18092 PyThreadState* __tstate = wxPyBeginAllowThreads();
18093 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18094
18095 wxPyEndAllowThreads(__tstate);
18096 if (PyErr_Occurred()) SWIG_fail;
18097 }
18098 {
18099 resultobj = SWIG_From_int((int)(result));
18100 }
18101 return resultobj;
18102 fail:
18103 return NULL;
18104 }
18105
18106
18107 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18108 PyObject *resultobj;
18109 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18110 int result;
18111 PyObject * obj0 = 0 ;
18112 char *kwnames[] = {
18113 (char *) "self", NULL
18114 };
18115
18116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18118 if (SWIG_arg_fail(1)) SWIG_fail;
18119 {
18120 PyThreadState* __tstate = wxPyBeginAllowThreads();
18121 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18122
18123 wxPyEndAllowThreads(__tstate);
18124 if (PyErr_Occurred()) SWIG_fail;
18125 }
18126 {
18127 resultobj = SWIG_From_int((int)(result));
18128 }
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18136 PyObject *resultobj;
18137 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18138 unsigned int result;
18139 PyObject * obj0 = 0 ;
18140 char *kwnames[] = {
18141 (char *) "self", NULL
18142 };
18143
18144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18146 if (SWIG_arg_fail(1)) SWIG_fail;
18147 {
18148 PyThreadState* __tstate = wxPyBeginAllowThreads();
18149 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18150
18151 wxPyEndAllowThreads(__tstate);
18152 if (PyErr_Occurred()) SWIG_fail;
18153 }
18154 {
18155 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18156 }
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18164 PyObject *resultobj;
18165 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18166 unsigned int result;
18167 PyObject * obj0 = 0 ;
18168 char *kwnames[] = {
18169 (char *) "self", NULL
18170 };
18171
18172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18174 if (SWIG_arg_fail(1)) SWIG_fail;
18175 {
18176 PyThreadState* __tstate = wxPyBeginAllowThreads();
18177 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18178
18179 wxPyEndAllowThreads(__tstate);
18180 if (PyErr_Occurred()) SWIG_fail;
18181 }
18182 {
18183 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18184 }
18185 return resultobj;
18186 fail:
18187 return NULL;
18188 }
18189
18190
18191 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18192 PyObject *resultobj;
18193 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18194 wxPoint result;
18195 PyObject * obj0 = 0 ;
18196 char *kwnames[] = {
18197 (char *) "self", NULL
18198 };
18199
18200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18202 if (SWIG_arg_fail(1)) SWIG_fail;
18203 {
18204 PyThreadState* __tstate = wxPyBeginAllowThreads();
18205 result = (arg1)->GetPosition();
18206
18207 wxPyEndAllowThreads(__tstate);
18208 if (PyErr_Occurred()) SWIG_fail;
18209 }
18210 {
18211 wxPoint * resultptr;
18212 resultptr = new wxPoint((wxPoint &)(result));
18213 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18214 }
18215 return resultobj;
18216 fail:
18217 return NULL;
18218 }
18219
18220
18221 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18222 PyObject *resultobj;
18223 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18224 long *arg2 = (long *) 0 ;
18225 long *arg3 = (long *) 0 ;
18226 long temp2 ;
18227 int res2 = 0 ;
18228 long temp3 ;
18229 int res3 = 0 ;
18230 PyObject * obj0 = 0 ;
18231 char *kwnames[] = {
18232 (char *) "self", NULL
18233 };
18234
18235 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18236 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18239 if (SWIG_arg_fail(1)) SWIG_fail;
18240 {
18241 PyThreadState* __tstate = wxPyBeginAllowThreads();
18242 (arg1)->GetPosition(arg2,arg3);
18243
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 Py_INCREF(Py_None); resultobj = Py_None;
18248 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18249 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18250 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18251 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18252 return resultobj;
18253 fail:
18254 return NULL;
18255 }
18256
18257
18258 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18259 PyObject *resultobj;
18260 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18261 int result;
18262 PyObject * obj0 = 0 ;
18263 char *kwnames[] = {
18264 (char *) "self", NULL
18265 };
18266
18267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18269 if (SWIG_arg_fail(1)) SWIG_fail;
18270 {
18271 PyThreadState* __tstate = wxPyBeginAllowThreads();
18272 result = (int)((wxKeyEvent const *)arg1)->GetX();
18273
18274 wxPyEndAllowThreads(__tstate);
18275 if (PyErr_Occurred()) SWIG_fail;
18276 }
18277 {
18278 resultobj = SWIG_From_int((int)(result));
18279 }
18280 return resultobj;
18281 fail:
18282 return NULL;
18283 }
18284
18285
18286 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18287 PyObject *resultobj;
18288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18289 int result;
18290 PyObject * obj0 = 0 ;
18291 char *kwnames[] = {
18292 (char *) "self", NULL
18293 };
18294
18295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18297 if (SWIG_arg_fail(1)) SWIG_fail;
18298 {
18299 PyThreadState* __tstate = wxPyBeginAllowThreads();
18300 result = (int)((wxKeyEvent const *)arg1)->GetY();
18301
18302 wxPyEndAllowThreads(__tstate);
18303 if (PyErr_Occurred()) SWIG_fail;
18304 }
18305 {
18306 resultobj = SWIG_From_int((int)(result));
18307 }
18308 return resultobj;
18309 fail:
18310 return NULL;
18311 }
18312
18313
18314 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18315 PyObject *resultobj;
18316 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18317 int arg2 ;
18318 PyObject * obj0 = 0 ;
18319 PyObject * obj1 = 0 ;
18320 char *kwnames[] = {
18321 (char *) "self",(char *) "m_x", NULL
18322 };
18323
18324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18326 if (SWIG_arg_fail(1)) SWIG_fail;
18327 {
18328 arg2 = (int)(SWIG_As_int(obj1));
18329 if (SWIG_arg_fail(2)) SWIG_fail;
18330 }
18331 if (arg1) (arg1)->m_x = arg2;
18332
18333 Py_INCREF(Py_None); resultobj = Py_None;
18334 return resultobj;
18335 fail:
18336 return NULL;
18337 }
18338
18339
18340 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18341 PyObject *resultobj;
18342 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18343 int result;
18344 PyObject * obj0 = 0 ;
18345 char *kwnames[] = {
18346 (char *) "self", NULL
18347 };
18348
18349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18351 if (SWIG_arg_fail(1)) SWIG_fail;
18352 result = (int) ((arg1)->m_x);
18353
18354 {
18355 resultobj = SWIG_From_int((int)(result));
18356 }
18357 return resultobj;
18358 fail:
18359 return NULL;
18360 }
18361
18362
18363 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18364 PyObject *resultobj;
18365 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18366 int arg2 ;
18367 PyObject * obj0 = 0 ;
18368 PyObject * obj1 = 0 ;
18369 char *kwnames[] = {
18370 (char *) "self",(char *) "m_y", NULL
18371 };
18372
18373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18375 if (SWIG_arg_fail(1)) SWIG_fail;
18376 {
18377 arg2 = (int)(SWIG_As_int(obj1));
18378 if (SWIG_arg_fail(2)) SWIG_fail;
18379 }
18380 if (arg1) (arg1)->m_y = arg2;
18381
18382 Py_INCREF(Py_None); resultobj = Py_None;
18383 return resultobj;
18384 fail:
18385 return NULL;
18386 }
18387
18388
18389 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18390 PyObject *resultobj;
18391 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18392 int result;
18393 PyObject * obj0 = 0 ;
18394 char *kwnames[] = {
18395 (char *) "self", NULL
18396 };
18397
18398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18400 if (SWIG_arg_fail(1)) SWIG_fail;
18401 result = (int) ((arg1)->m_y);
18402
18403 {
18404 resultobj = SWIG_From_int((int)(result));
18405 }
18406 return resultobj;
18407 fail:
18408 return NULL;
18409 }
18410
18411
18412 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18413 PyObject *resultobj;
18414 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18415 long arg2 ;
18416 PyObject * obj0 = 0 ;
18417 PyObject * obj1 = 0 ;
18418 char *kwnames[] = {
18419 (char *) "self",(char *) "m_keyCode", NULL
18420 };
18421
18422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18424 if (SWIG_arg_fail(1)) SWIG_fail;
18425 {
18426 arg2 = (long)(SWIG_As_long(obj1));
18427 if (SWIG_arg_fail(2)) SWIG_fail;
18428 }
18429 if (arg1) (arg1)->m_keyCode = arg2;
18430
18431 Py_INCREF(Py_None); resultobj = Py_None;
18432 return resultobj;
18433 fail:
18434 return NULL;
18435 }
18436
18437
18438 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18439 PyObject *resultobj;
18440 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18441 long result;
18442 PyObject * obj0 = 0 ;
18443 char *kwnames[] = {
18444 (char *) "self", NULL
18445 };
18446
18447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18449 if (SWIG_arg_fail(1)) SWIG_fail;
18450 result = (long) ((arg1)->m_keyCode);
18451
18452 {
18453 resultobj = SWIG_From_long((long)(result));
18454 }
18455 return resultobj;
18456 fail:
18457 return NULL;
18458 }
18459
18460
18461 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18462 PyObject *resultobj;
18463 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18464 bool arg2 ;
18465 PyObject * obj0 = 0 ;
18466 PyObject * obj1 = 0 ;
18467 char *kwnames[] = {
18468 (char *) "self",(char *) "m_controlDown", NULL
18469 };
18470
18471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18473 if (SWIG_arg_fail(1)) SWIG_fail;
18474 {
18475 arg2 = (bool)(SWIG_As_bool(obj1));
18476 if (SWIG_arg_fail(2)) SWIG_fail;
18477 }
18478 if (arg1) (arg1)->m_controlDown = arg2;
18479
18480 Py_INCREF(Py_None); resultobj = Py_None;
18481 return resultobj;
18482 fail:
18483 return NULL;
18484 }
18485
18486
18487 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18488 PyObject *resultobj;
18489 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18490 bool result;
18491 PyObject * obj0 = 0 ;
18492 char *kwnames[] = {
18493 (char *) "self", NULL
18494 };
18495
18496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18498 if (SWIG_arg_fail(1)) SWIG_fail;
18499 result = (bool) ((arg1)->m_controlDown);
18500
18501 {
18502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18503 }
18504 return resultobj;
18505 fail:
18506 return NULL;
18507 }
18508
18509
18510 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18511 PyObject *resultobj;
18512 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18513 bool arg2 ;
18514 PyObject * obj0 = 0 ;
18515 PyObject * obj1 = 0 ;
18516 char *kwnames[] = {
18517 (char *) "self",(char *) "m_shiftDown", NULL
18518 };
18519
18520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18522 if (SWIG_arg_fail(1)) SWIG_fail;
18523 {
18524 arg2 = (bool)(SWIG_As_bool(obj1));
18525 if (SWIG_arg_fail(2)) SWIG_fail;
18526 }
18527 if (arg1) (arg1)->m_shiftDown = arg2;
18528
18529 Py_INCREF(Py_None); resultobj = Py_None;
18530 return resultobj;
18531 fail:
18532 return NULL;
18533 }
18534
18535
18536 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18537 PyObject *resultobj;
18538 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18539 bool result;
18540 PyObject * obj0 = 0 ;
18541 char *kwnames[] = {
18542 (char *) "self", NULL
18543 };
18544
18545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18547 if (SWIG_arg_fail(1)) SWIG_fail;
18548 result = (bool) ((arg1)->m_shiftDown);
18549
18550 {
18551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18552 }
18553 return resultobj;
18554 fail:
18555 return NULL;
18556 }
18557
18558
18559 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18560 PyObject *resultobj;
18561 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18562 bool arg2 ;
18563 PyObject * obj0 = 0 ;
18564 PyObject * obj1 = 0 ;
18565 char *kwnames[] = {
18566 (char *) "self",(char *) "m_altDown", NULL
18567 };
18568
18569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18571 if (SWIG_arg_fail(1)) SWIG_fail;
18572 {
18573 arg2 = (bool)(SWIG_As_bool(obj1));
18574 if (SWIG_arg_fail(2)) SWIG_fail;
18575 }
18576 if (arg1) (arg1)->m_altDown = arg2;
18577
18578 Py_INCREF(Py_None); resultobj = Py_None;
18579 return resultobj;
18580 fail:
18581 return NULL;
18582 }
18583
18584
18585 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18586 PyObject *resultobj;
18587 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18588 bool result;
18589 PyObject * obj0 = 0 ;
18590 char *kwnames[] = {
18591 (char *) "self", NULL
18592 };
18593
18594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18596 if (SWIG_arg_fail(1)) SWIG_fail;
18597 result = (bool) ((arg1)->m_altDown);
18598
18599 {
18600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18601 }
18602 return resultobj;
18603 fail:
18604 return NULL;
18605 }
18606
18607
18608 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18609 PyObject *resultobj;
18610 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18611 bool arg2 ;
18612 PyObject * obj0 = 0 ;
18613 PyObject * obj1 = 0 ;
18614 char *kwnames[] = {
18615 (char *) "self",(char *) "m_metaDown", NULL
18616 };
18617
18618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18620 if (SWIG_arg_fail(1)) SWIG_fail;
18621 {
18622 arg2 = (bool)(SWIG_As_bool(obj1));
18623 if (SWIG_arg_fail(2)) SWIG_fail;
18624 }
18625 if (arg1) (arg1)->m_metaDown = arg2;
18626
18627 Py_INCREF(Py_None); resultobj = Py_None;
18628 return resultobj;
18629 fail:
18630 return NULL;
18631 }
18632
18633
18634 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18635 PyObject *resultobj;
18636 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18637 bool result;
18638 PyObject * obj0 = 0 ;
18639 char *kwnames[] = {
18640 (char *) "self", NULL
18641 };
18642
18643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18645 if (SWIG_arg_fail(1)) SWIG_fail;
18646 result = (bool) ((arg1)->m_metaDown);
18647
18648 {
18649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18650 }
18651 return resultobj;
18652 fail:
18653 return NULL;
18654 }
18655
18656
18657 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18658 PyObject *resultobj;
18659 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18660 bool arg2 ;
18661 PyObject * obj0 = 0 ;
18662 PyObject * obj1 = 0 ;
18663 char *kwnames[] = {
18664 (char *) "self",(char *) "m_scanCode", NULL
18665 };
18666
18667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18669 if (SWIG_arg_fail(1)) SWIG_fail;
18670 {
18671 arg2 = (bool)(SWIG_As_bool(obj1));
18672 if (SWIG_arg_fail(2)) SWIG_fail;
18673 }
18674 if (arg1) (arg1)->m_scanCode = arg2;
18675
18676 Py_INCREF(Py_None); resultobj = Py_None;
18677 return resultobj;
18678 fail:
18679 return NULL;
18680 }
18681
18682
18683 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18684 PyObject *resultobj;
18685 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18686 bool result;
18687 PyObject * obj0 = 0 ;
18688 char *kwnames[] = {
18689 (char *) "self", NULL
18690 };
18691
18692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18694 if (SWIG_arg_fail(1)) SWIG_fail;
18695 result = (bool) ((arg1)->m_scanCode);
18696
18697 {
18698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18699 }
18700 return resultobj;
18701 fail:
18702 return NULL;
18703 }
18704
18705
18706 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18707 PyObject *resultobj;
18708 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18709 unsigned int arg2 ;
18710 PyObject * obj0 = 0 ;
18711 PyObject * obj1 = 0 ;
18712 char *kwnames[] = {
18713 (char *) "self",(char *) "m_rawCode", NULL
18714 };
18715
18716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18718 if (SWIG_arg_fail(1)) SWIG_fail;
18719 {
18720 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18721 if (SWIG_arg_fail(2)) SWIG_fail;
18722 }
18723 if (arg1) (arg1)->m_rawCode = arg2;
18724
18725 Py_INCREF(Py_None); resultobj = Py_None;
18726 return resultobj;
18727 fail:
18728 return NULL;
18729 }
18730
18731
18732 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18733 PyObject *resultobj;
18734 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18735 unsigned int result;
18736 PyObject * obj0 = 0 ;
18737 char *kwnames[] = {
18738 (char *) "self", NULL
18739 };
18740
18741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18743 if (SWIG_arg_fail(1)) SWIG_fail;
18744 result = (unsigned int) ((arg1)->m_rawCode);
18745
18746 {
18747 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18748 }
18749 return resultobj;
18750 fail:
18751 return NULL;
18752 }
18753
18754
18755 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18756 PyObject *resultobj;
18757 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18758 unsigned int arg2 ;
18759 PyObject * obj0 = 0 ;
18760 PyObject * obj1 = 0 ;
18761 char *kwnames[] = {
18762 (char *) "self",(char *) "m_rawFlags", NULL
18763 };
18764
18765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18767 if (SWIG_arg_fail(1)) SWIG_fail;
18768 {
18769 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18770 if (SWIG_arg_fail(2)) SWIG_fail;
18771 }
18772 if (arg1) (arg1)->m_rawFlags = arg2;
18773
18774 Py_INCREF(Py_None); resultobj = Py_None;
18775 return resultobj;
18776 fail:
18777 return NULL;
18778 }
18779
18780
18781 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18782 PyObject *resultobj;
18783 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18784 unsigned int result;
18785 PyObject * obj0 = 0 ;
18786 char *kwnames[] = {
18787 (char *) "self", NULL
18788 };
18789
18790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18792 if (SWIG_arg_fail(1)) SWIG_fail;
18793 result = (unsigned int) ((arg1)->m_rawFlags);
18794
18795 {
18796 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18797 }
18798 return resultobj;
18799 fail:
18800 return NULL;
18801 }
18802
18803
18804 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18805 PyObject *obj;
18806 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18807 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18808 Py_INCREF(obj);
18809 return Py_BuildValue((char *)"");
18810 }
18811 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18812 PyObject *resultobj;
18813 wxSize const &arg1_defvalue = wxDefaultSize ;
18814 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18815 int arg2 = (int) 0 ;
18816 wxSizeEvent *result;
18817 wxSize temp1 ;
18818 PyObject * obj0 = 0 ;
18819 PyObject * obj1 = 0 ;
18820 char *kwnames[] = {
18821 (char *) "sz",(char *) "winid", NULL
18822 };
18823
18824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18825 if (obj0) {
18826 {
18827 arg1 = &temp1;
18828 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18829 }
18830 }
18831 if (obj1) {
18832 {
18833 arg2 = (int)(SWIG_As_int(obj1));
18834 if (SWIG_arg_fail(2)) SWIG_fail;
18835 }
18836 }
18837 {
18838 PyThreadState* __tstate = wxPyBeginAllowThreads();
18839 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18840
18841 wxPyEndAllowThreads(__tstate);
18842 if (PyErr_Occurred()) SWIG_fail;
18843 }
18844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18845 return resultobj;
18846 fail:
18847 return NULL;
18848 }
18849
18850
18851 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18852 PyObject *resultobj;
18853 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18854 wxSize result;
18855 PyObject * obj0 = 0 ;
18856 char *kwnames[] = {
18857 (char *) "self", NULL
18858 };
18859
18860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18862 if (SWIG_arg_fail(1)) SWIG_fail;
18863 {
18864 PyThreadState* __tstate = wxPyBeginAllowThreads();
18865 result = ((wxSizeEvent const *)arg1)->GetSize();
18866
18867 wxPyEndAllowThreads(__tstate);
18868 if (PyErr_Occurred()) SWIG_fail;
18869 }
18870 {
18871 wxSize * resultptr;
18872 resultptr = new wxSize((wxSize &)(result));
18873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18874 }
18875 return resultobj;
18876 fail:
18877 return NULL;
18878 }
18879
18880
18881 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18882 PyObject *resultobj;
18883 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18884 wxRect result;
18885 PyObject * obj0 = 0 ;
18886 char *kwnames[] = {
18887 (char *) "self", NULL
18888 };
18889
18890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18892 if (SWIG_arg_fail(1)) SWIG_fail;
18893 {
18894 PyThreadState* __tstate = wxPyBeginAllowThreads();
18895 result = ((wxSizeEvent const *)arg1)->GetRect();
18896
18897 wxPyEndAllowThreads(__tstate);
18898 if (PyErr_Occurred()) SWIG_fail;
18899 }
18900 {
18901 wxRect * resultptr;
18902 resultptr = new wxRect((wxRect &)(result));
18903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18904 }
18905 return resultobj;
18906 fail:
18907 return NULL;
18908 }
18909
18910
18911 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18912 PyObject *resultobj;
18913 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18914 wxRect arg2 ;
18915 PyObject * obj0 = 0 ;
18916 PyObject * obj1 = 0 ;
18917 char *kwnames[] = {
18918 (char *) "self",(char *) "rect", NULL
18919 };
18920
18921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18923 if (SWIG_arg_fail(1)) SWIG_fail;
18924 {
18925 wxRect * argp;
18926 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18927 if (SWIG_arg_fail(2)) SWIG_fail;
18928 if (argp == NULL) {
18929 SWIG_null_ref("wxRect");
18930 }
18931 if (SWIG_arg_fail(2)) SWIG_fail;
18932 arg2 = *argp;
18933 }
18934 {
18935 PyThreadState* __tstate = wxPyBeginAllowThreads();
18936 (arg1)->SetRect(arg2);
18937
18938 wxPyEndAllowThreads(__tstate);
18939 if (PyErr_Occurred()) SWIG_fail;
18940 }
18941 Py_INCREF(Py_None); resultobj = Py_None;
18942 return resultobj;
18943 fail:
18944 return NULL;
18945 }
18946
18947
18948 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18949 PyObject *resultobj;
18950 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18951 wxSize arg2 ;
18952 PyObject * obj0 = 0 ;
18953 PyObject * obj1 = 0 ;
18954 char *kwnames[] = {
18955 (char *) "self",(char *) "size", NULL
18956 };
18957
18958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18960 if (SWIG_arg_fail(1)) SWIG_fail;
18961 {
18962 wxSize * argp;
18963 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18964 if (SWIG_arg_fail(2)) SWIG_fail;
18965 if (argp == NULL) {
18966 SWIG_null_ref("wxSize");
18967 }
18968 if (SWIG_arg_fail(2)) SWIG_fail;
18969 arg2 = *argp;
18970 }
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 wxSizeEvent_SetSize(arg1,arg2);
18974
18975 wxPyEndAllowThreads(__tstate);
18976 if (PyErr_Occurred()) SWIG_fail;
18977 }
18978 Py_INCREF(Py_None); resultobj = Py_None;
18979 return resultobj;
18980 fail:
18981 return NULL;
18982 }
18983
18984
18985 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18986 PyObject *resultobj;
18987 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18988 wxSize *arg2 = (wxSize *) 0 ;
18989 PyObject * obj0 = 0 ;
18990 PyObject * obj1 = 0 ;
18991 char *kwnames[] = {
18992 (char *) "self",(char *) "m_size", NULL
18993 };
18994
18995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18997 if (SWIG_arg_fail(1)) SWIG_fail;
18998 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18999 if (SWIG_arg_fail(2)) SWIG_fail;
19000 if (arg1) (arg1)->m_size = *arg2;
19001
19002 Py_INCREF(Py_None); resultobj = Py_None;
19003 return resultobj;
19004 fail:
19005 return NULL;
19006 }
19007
19008
19009 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19010 PyObject *resultobj;
19011 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19012 wxSize *result;
19013 PyObject * obj0 = 0 ;
19014 char *kwnames[] = {
19015 (char *) "self", NULL
19016 };
19017
19018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19020 if (SWIG_arg_fail(1)) SWIG_fail;
19021 result = (wxSize *)& ((arg1)->m_size);
19022
19023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19024 return resultobj;
19025 fail:
19026 return NULL;
19027 }
19028
19029
19030 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19031 PyObject *resultobj;
19032 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19033 wxRect *arg2 = (wxRect *) 0 ;
19034 PyObject * obj0 = 0 ;
19035 PyObject * obj1 = 0 ;
19036 char *kwnames[] = {
19037 (char *) "self",(char *) "m_rect", NULL
19038 };
19039
19040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19042 if (SWIG_arg_fail(1)) SWIG_fail;
19043 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19044 if (SWIG_arg_fail(2)) SWIG_fail;
19045 if (arg1) (arg1)->m_rect = *arg2;
19046
19047 Py_INCREF(Py_None); resultobj = Py_None;
19048 return resultobj;
19049 fail:
19050 return NULL;
19051 }
19052
19053
19054 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19055 PyObject *resultobj;
19056 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19057 wxRect *result;
19058 PyObject * obj0 = 0 ;
19059 char *kwnames[] = {
19060 (char *) "self", NULL
19061 };
19062
19063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19065 if (SWIG_arg_fail(1)) SWIG_fail;
19066 result = (wxRect *)& ((arg1)->m_rect);
19067
19068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19069 return resultobj;
19070 fail:
19071 return NULL;
19072 }
19073
19074
19075 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19076 PyObject *obj;
19077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19078 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19079 Py_INCREF(obj);
19080 return Py_BuildValue((char *)"");
19081 }
19082 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19083 PyObject *resultobj;
19084 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19085 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19086 int arg2 = (int) 0 ;
19087 wxMoveEvent *result;
19088 wxPoint temp1 ;
19089 PyObject * obj0 = 0 ;
19090 PyObject * obj1 = 0 ;
19091 char *kwnames[] = {
19092 (char *) "pos",(char *) "winid", NULL
19093 };
19094
19095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19096 if (obj0) {
19097 {
19098 arg1 = &temp1;
19099 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19100 }
19101 }
19102 if (obj1) {
19103 {
19104 arg2 = (int)(SWIG_As_int(obj1));
19105 if (SWIG_arg_fail(2)) SWIG_fail;
19106 }
19107 }
19108 {
19109 PyThreadState* __tstate = wxPyBeginAllowThreads();
19110 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19111
19112 wxPyEndAllowThreads(__tstate);
19113 if (PyErr_Occurred()) SWIG_fail;
19114 }
19115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19116 return resultobj;
19117 fail:
19118 return NULL;
19119 }
19120
19121
19122 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19123 PyObject *resultobj;
19124 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19125 wxPoint result;
19126 PyObject * obj0 = 0 ;
19127 char *kwnames[] = {
19128 (char *) "self", NULL
19129 };
19130
19131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19133 if (SWIG_arg_fail(1)) SWIG_fail;
19134 {
19135 PyThreadState* __tstate = wxPyBeginAllowThreads();
19136 result = ((wxMoveEvent const *)arg1)->GetPosition();
19137
19138 wxPyEndAllowThreads(__tstate);
19139 if (PyErr_Occurred()) SWIG_fail;
19140 }
19141 {
19142 wxPoint * resultptr;
19143 resultptr = new wxPoint((wxPoint &)(result));
19144 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19145 }
19146 return resultobj;
19147 fail:
19148 return NULL;
19149 }
19150
19151
19152 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19153 PyObject *resultobj;
19154 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19155 wxRect result;
19156 PyObject * obj0 = 0 ;
19157 char *kwnames[] = {
19158 (char *) "self", NULL
19159 };
19160
19161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19163 if (SWIG_arg_fail(1)) SWIG_fail;
19164 {
19165 PyThreadState* __tstate = wxPyBeginAllowThreads();
19166 result = ((wxMoveEvent const *)arg1)->GetRect();
19167
19168 wxPyEndAllowThreads(__tstate);
19169 if (PyErr_Occurred()) SWIG_fail;
19170 }
19171 {
19172 wxRect * resultptr;
19173 resultptr = new wxRect((wxRect &)(result));
19174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19175 }
19176 return resultobj;
19177 fail:
19178 return NULL;
19179 }
19180
19181
19182 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19183 PyObject *resultobj;
19184 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19185 wxRect *arg2 = 0 ;
19186 wxRect temp2 ;
19187 PyObject * obj0 = 0 ;
19188 PyObject * obj1 = 0 ;
19189 char *kwnames[] = {
19190 (char *) "self",(char *) "rect", NULL
19191 };
19192
19193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19195 if (SWIG_arg_fail(1)) SWIG_fail;
19196 {
19197 arg2 = &temp2;
19198 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19199 }
19200 {
19201 PyThreadState* __tstate = wxPyBeginAllowThreads();
19202 (arg1)->SetRect((wxRect const &)*arg2);
19203
19204 wxPyEndAllowThreads(__tstate);
19205 if (PyErr_Occurred()) SWIG_fail;
19206 }
19207 Py_INCREF(Py_None); resultobj = Py_None;
19208 return resultobj;
19209 fail:
19210 return NULL;
19211 }
19212
19213
19214 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19215 PyObject *resultobj;
19216 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19217 wxPoint *arg2 = 0 ;
19218 wxPoint temp2 ;
19219 PyObject * obj0 = 0 ;
19220 PyObject * obj1 = 0 ;
19221 char *kwnames[] = {
19222 (char *) "self",(char *) "pos", NULL
19223 };
19224
19225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19227 if (SWIG_arg_fail(1)) SWIG_fail;
19228 {
19229 arg2 = &temp2;
19230 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19231 }
19232 {
19233 PyThreadState* __tstate = wxPyBeginAllowThreads();
19234 (arg1)->SetPosition((wxPoint const &)*arg2);
19235
19236 wxPyEndAllowThreads(__tstate);
19237 if (PyErr_Occurred()) SWIG_fail;
19238 }
19239 Py_INCREF(Py_None); resultobj = Py_None;
19240 return resultobj;
19241 fail:
19242 return NULL;
19243 }
19244
19245
19246 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19247 PyObject *obj;
19248 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19249 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19250 Py_INCREF(obj);
19251 return Py_BuildValue((char *)"");
19252 }
19253 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19254 PyObject *resultobj;
19255 int arg1 = (int) 0 ;
19256 wxPaintEvent *result;
19257 PyObject * obj0 = 0 ;
19258 char *kwnames[] = {
19259 (char *) "Id", NULL
19260 };
19261
19262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19263 if (obj0) {
19264 {
19265 arg1 = (int)(SWIG_As_int(obj0));
19266 if (SWIG_arg_fail(1)) SWIG_fail;
19267 }
19268 }
19269 {
19270 PyThreadState* __tstate = wxPyBeginAllowThreads();
19271 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19272
19273 wxPyEndAllowThreads(__tstate);
19274 if (PyErr_Occurred()) SWIG_fail;
19275 }
19276 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19277 return resultobj;
19278 fail:
19279 return NULL;
19280 }
19281
19282
19283 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19284 PyObject *obj;
19285 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19286 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19287 Py_INCREF(obj);
19288 return Py_BuildValue((char *)"");
19289 }
19290 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19291 PyObject *resultobj;
19292 int arg1 = (int) 0 ;
19293 wxNcPaintEvent *result;
19294 PyObject * obj0 = 0 ;
19295 char *kwnames[] = {
19296 (char *) "winid", NULL
19297 };
19298
19299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19300 if (obj0) {
19301 {
19302 arg1 = (int)(SWIG_As_int(obj0));
19303 if (SWIG_arg_fail(1)) SWIG_fail;
19304 }
19305 }
19306 {
19307 PyThreadState* __tstate = wxPyBeginAllowThreads();
19308 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19309
19310 wxPyEndAllowThreads(__tstate);
19311 if (PyErr_Occurred()) SWIG_fail;
19312 }
19313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19314 return resultobj;
19315 fail:
19316 return NULL;
19317 }
19318
19319
19320 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19321 PyObject *obj;
19322 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19323 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19324 Py_INCREF(obj);
19325 return Py_BuildValue((char *)"");
19326 }
19327 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19328 PyObject *resultobj;
19329 int arg1 = (int) 0 ;
19330 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19331 wxEraseEvent *result;
19332 PyObject * obj0 = 0 ;
19333 PyObject * obj1 = 0 ;
19334 char *kwnames[] = {
19335 (char *) "Id",(char *) "dc", NULL
19336 };
19337
19338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19339 if (obj0) {
19340 {
19341 arg1 = (int)(SWIG_As_int(obj0));
19342 if (SWIG_arg_fail(1)) SWIG_fail;
19343 }
19344 }
19345 if (obj1) {
19346 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19347 if (SWIG_arg_fail(2)) SWIG_fail;
19348 }
19349 {
19350 PyThreadState* __tstate = wxPyBeginAllowThreads();
19351 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19352
19353 wxPyEndAllowThreads(__tstate);
19354 if (PyErr_Occurred()) SWIG_fail;
19355 }
19356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19357 return resultobj;
19358 fail:
19359 return NULL;
19360 }
19361
19362
19363 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19364 PyObject *resultobj;
19365 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19366 wxDC *result;
19367 PyObject * obj0 = 0 ;
19368 char *kwnames[] = {
19369 (char *) "self", NULL
19370 };
19371
19372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19374 if (SWIG_arg_fail(1)) SWIG_fail;
19375 {
19376 PyThreadState* __tstate = wxPyBeginAllowThreads();
19377 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19378
19379 wxPyEndAllowThreads(__tstate);
19380 if (PyErr_Occurred()) SWIG_fail;
19381 }
19382 {
19383 resultobj = wxPyMake_wxObject(result, 0);
19384 }
19385 return resultobj;
19386 fail:
19387 return NULL;
19388 }
19389
19390
19391 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19392 PyObject *obj;
19393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19394 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19395 Py_INCREF(obj);
19396 return Py_BuildValue((char *)"");
19397 }
19398 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19399 PyObject *resultobj;
19400 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19401 int arg2 = (int) 0 ;
19402 wxFocusEvent *result;
19403 PyObject * obj0 = 0 ;
19404 PyObject * obj1 = 0 ;
19405 char *kwnames[] = {
19406 (char *) "type",(char *) "winid", NULL
19407 };
19408
19409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19410 if (obj0) {
19411 {
19412 arg1 = (wxEventType)(SWIG_As_int(obj0));
19413 if (SWIG_arg_fail(1)) SWIG_fail;
19414 }
19415 }
19416 if (obj1) {
19417 {
19418 arg2 = (int)(SWIG_As_int(obj1));
19419 if (SWIG_arg_fail(2)) SWIG_fail;
19420 }
19421 }
19422 {
19423 PyThreadState* __tstate = wxPyBeginAllowThreads();
19424 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19425
19426 wxPyEndAllowThreads(__tstate);
19427 if (PyErr_Occurred()) SWIG_fail;
19428 }
19429 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19430 return resultobj;
19431 fail:
19432 return NULL;
19433 }
19434
19435
19436 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19437 PyObject *resultobj;
19438 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19439 wxWindow *result;
19440 PyObject * obj0 = 0 ;
19441 char *kwnames[] = {
19442 (char *) "self", NULL
19443 };
19444
19445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19447 if (SWIG_arg_fail(1)) SWIG_fail;
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19451
19452 wxPyEndAllowThreads(__tstate);
19453 if (PyErr_Occurred()) SWIG_fail;
19454 }
19455 {
19456 resultobj = wxPyMake_wxObject(result, 0);
19457 }
19458 return resultobj;
19459 fail:
19460 return NULL;
19461 }
19462
19463
19464 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19465 PyObject *resultobj;
19466 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19467 wxWindow *arg2 = (wxWindow *) 0 ;
19468 PyObject * obj0 = 0 ;
19469 PyObject * obj1 = 0 ;
19470 char *kwnames[] = {
19471 (char *) "self",(char *) "win", NULL
19472 };
19473
19474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19476 if (SWIG_arg_fail(1)) SWIG_fail;
19477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19478 if (SWIG_arg_fail(2)) SWIG_fail;
19479 {
19480 PyThreadState* __tstate = wxPyBeginAllowThreads();
19481 (arg1)->SetWindow(arg2);
19482
19483 wxPyEndAllowThreads(__tstate);
19484 if (PyErr_Occurred()) SWIG_fail;
19485 }
19486 Py_INCREF(Py_None); resultobj = Py_None;
19487 return resultobj;
19488 fail:
19489 return NULL;
19490 }
19491
19492
19493 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19494 PyObject *obj;
19495 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19496 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19497 Py_INCREF(obj);
19498 return Py_BuildValue((char *)"");
19499 }
19500 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19501 PyObject *resultobj;
19502 wxWindow *arg1 = (wxWindow *) NULL ;
19503 wxChildFocusEvent *result;
19504 PyObject * obj0 = 0 ;
19505 char *kwnames[] = {
19506 (char *) "win", NULL
19507 };
19508
19509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19510 if (obj0) {
19511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19512 if (SWIG_arg_fail(1)) SWIG_fail;
19513 }
19514 {
19515 PyThreadState* __tstate = wxPyBeginAllowThreads();
19516 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19517
19518 wxPyEndAllowThreads(__tstate);
19519 if (PyErr_Occurred()) SWIG_fail;
19520 }
19521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19522 return resultobj;
19523 fail:
19524 return NULL;
19525 }
19526
19527
19528 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19529 PyObject *resultobj;
19530 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19531 wxWindow *result;
19532 PyObject * obj0 = 0 ;
19533 char *kwnames[] = {
19534 (char *) "self", NULL
19535 };
19536
19537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19539 if (SWIG_arg_fail(1)) SWIG_fail;
19540 {
19541 PyThreadState* __tstate = wxPyBeginAllowThreads();
19542 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19543
19544 wxPyEndAllowThreads(__tstate);
19545 if (PyErr_Occurred()) SWIG_fail;
19546 }
19547 {
19548 resultobj = wxPyMake_wxObject(result, 0);
19549 }
19550 return resultobj;
19551 fail:
19552 return NULL;
19553 }
19554
19555
19556 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19557 PyObject *obj;
19558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19559 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19560 Py_INCREF(obj);
19561 return Py_BuildValue((char *)"");
19562 }
19563 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19564 PyObject *resultobj;
19565 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19566 bool arg2 = (bool) true ;
19567 int arg3 = (int) 0 ;
19568 wxActivateEvent *result;
19569 PyObject * obj0 = 0 ;
19570 PyObject * obj1 = 0 ;
19571 PyObject * obj2 = 0 ;
19572 char *kwnames[] = {
19573 (char *) "type",(char *) "active",(char *) "Id", NULL
19574 };
19575
19576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19577 if (obj0) {
19578 {
19579 arg1 = (wxEventType)(SWIG_As_int(obj0));
19580 if (SWIG_arg_fail(1)) SWIG_fail;
19581 }
19582 }
19583 if (obj1) {
19584 {
19585 arg2 = (bool)(SWIG_As_bool(obj1));
19586 if (SWIG_arg_fail(2)) SWIG_fail;
19587 }
19588 }
19589 if (obj2) {
19590 {
19591 arg3 = (int)(SWIG_As_int(obj2));
19592 if (SWIG_arg_fail(3)) SWIG_fail;
19593 }
19594 }
19595 {
19596 PyThreadState* __tstate = wxPyBeginAllowThreads();
19597 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19598
19599 wxPyEndAllowThreads(__tstate);
19600 if (PyErr_Occurred()) SWIG_fail;
19601 }
19602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19603 return resultobj;
19604 fail:
19605 return NULL;
19606 }
19607
19608
19609 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19610 PyObject *resultobj;
19611 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19612 bool result;
19613 PyObject * obj0 = 0 ;
19614 char *kwnames[] = {
19615 (char *) "self", NULL
19616 };
19617
19618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19620 if (SWIG_arg_fail(1)) SWIG_fail;
19621 {
19622 PyThreadState* __tstate = wxPyBeginAllowThreads();
19623 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19624
19625 wxPyEndAllowThreads(__tstate);
19626 if (PyErr_Occurred()) SWIG_fail;
19627 }
19628 {
19629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19630 }
19631 return resultobj;
19632 fail:
19633 return NULL;
19634 }
19635
19636
19637 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19638 PyObject *obj;
19639 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19640 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19641 Py_INCREF(obj);
19642 return Py_BuildValue((char *)"");
19643 }
19644 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19645 PyObject *resultobj;
19646 int arg1 = (int) 0 ;
19647 wxInitDialogEvent *result;
19648 PyObject * obj0 = 0 ;
19649 char *kwnames[] = {
19650 (char *) "Id", NULL
19651 };
19652
19653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19654 if (obj0) {
19655 {
19656 arg1 = (int)(SWIG_As_int(obj0));
19657 if (SWIG_arg_fail(1)) SWIG_fail;
19658 }
19659 }
19660 {
19661 PyThreadState* __tstate = wxPyBeginAllowThreads();
19662 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19663
19664 wxPyEndAllowThreads(__tstate);
19665 if (PyErr_Occurred()) SWIG_fail;
19666 }
19667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19668 return resultobj;
19669 fail:
19670 return NULL;
19671 }
19672
19673
19674 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19675 PyObject *obj;
19676 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19677 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19678 Py_INCREF(obj);
19679 return Py_BuildValue((char *)"");
19680 }
19681 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19682 PyObject *resultobj;
19683 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19684 int arg2 = (int) 0 ;
19685 wxMenu *arg3 = (wxMenu *) NULL ;
19686 wxMenuEvent *result;
19687 PyObject * obj0 = 0 ;
19688 PyObject * obj1 = 0 ;
19689 PyObject * obj2 = 0 ;
19690 char *kwnames[] = {
19691 (char *) "type",(char *) "winid",(char *) "menu", NULL
19692 };
19693
19694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19695 if (obj0) {
19696 {
19697 arg1 = (wxEventType)(SWIG_As_int(obj0));
19698 if (SWIG_arg_fail(1)) SWIG_fail;
19699 }
19700 }
19701 if (obj1) {
19702 {
19703 arg2 = (int)(SWIG_As_int(obj1));
19704 if (SWIG_arg_fail(2)) SWIG_fail;
19705 }
19706 }
19707 if (obj2) {
19708 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19709 if (SWIG_arg_fail(3)) SWIG_fail;
19710 }
19711 {
19712 PyThreadState* __tstate = wxPyBeginAllowThreads();
19713 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19714
19715 wxPyEndAllowThreads(__tstate);
19716 if (PyErr_Occurred()) SWIG_fail;
19717 }
19718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19719 return resultobj;
19720 fail:
19721 return NULL;
19722 }
19723
19724
19725 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19726 PyObject *resultobj;
19727 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19728 int result;
19729 PyObject * obj0 = 0 ;
19730 char *kwnames[] = {
19731 (char *) "self", NULL
19732 };
19733
19734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19736 if (SWIG_arg_fail(1)) SWIG_fail;
19737 {
19738 PyThreadState* __tstate = wxPyBeginAllowThreads();
19739 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19740
19741 wxPyEndAllowThreads(__tstate);
19742 if (PyErr_Occurred()) SWIG_fail;
19743 }
19744 {
19745 resultobj = SWIG_From_int((int)(result));
19746 }
19747 return resultobj;
19748 fail:
19749 return NULL;
19750 }
19751
19752
19753 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19754 PyObject *resultobj;
19755 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19756 bool result;
19757 PyObject * obj0 = 0 ;
19758 char *kwnames[] = {
19759 (char *) "self", NULL
19760 };
19761
19762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19764 if (SWIG_arg_fail(1)) SWIG_fail;
19765 {
19766 PyThreadState* __tstate = wxPyBeginAllowThreads();
19767 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19768
19769 wxPyEndAllowThreads(__tstate);
19770 if (PyErr_Occurred()) SWIG_fail;
19771 }
19772 {
19773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19774 }
19775 return resultobj;
19776 fail:
19777 return NULL;
19778 }
19779
19780
19781 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19782 PyObject *resultobj;
19783 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19784 wxMenu *result;
19785 PyObject * obj0 = 0 ;
19786 char *kwnames[] = {
19787 (char *) "self", NULL
19788 };
19789
19790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19792 if (SWIG_arg_fail(1)) SWIG_fail;
19793 {
19794 PyThreadState* __tstate = wxPyBeginAllowThreads();
19795 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19796
19797 wxPyEndAllowThreads(__tstate);
19798 if (PyErr_Occurred()) SWIG_fail;
19799 }
19800 {
19801 resultobj = wxPyMake_wxObject(result, 0);
19802 }
19803 return resultobj;
19804 fail:
19805 return NULL;
19806 }
19807
19808
19809 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19810 PyObject *obj;
19811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19812 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19813 Py_INCREF(obj);
19814 return Py_BuildValue((char *)"");
19815 }
19816 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19817 PyObject *resultobj;
19818 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19819 int arg2 = (int) 0 ;
19820 wxCloseEvent *result;
19821 PyObject * obj0 = 0 ;
19822 PyObject * obj1 = 0 ;
19823 char *kwnames[] = {
19824 (char *) "type",(char *) "winid", NULL
19825 };
19826
19827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19828 if (obj0) {
19829 {
19830 arg1 = (wxEventType)(SWIG_As_int(obj0));
19831 if (SWIG_arg_fail(1)) SWIG_fail;
19832 }
19833 }
19834 if (obj1) {
19835 {
19836 arg2 = (int)(SWIG_As_int(obj1));
19837 if (SWIG_arg_fail(2)) SWIG_fail;
19838 }
19839 }
19840 {
19841 PyThreadState* __tstate = wxPyBeginAllowThreads();
19842 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19843
19844 wxPyEndAllowThreads(__tstate);
19845 if (PyErr_Occurred()) SWIG_fail;
19846 }
19847 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19848 return resultobj;
19849 fail:
19850 return NULL;
19851 }
19852
19853
19854 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19855 PyObject *resultobj;
19856 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19857 bool arg2 ;
19858 PyObject * obj0 = 0 ;
19859 PyObject * obj1 = 0 ;
19860 char *kwnames[] = {
19861 (char *) "self",(char *) "logOff", NULL
19862 };
19863
19864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19866 if (SWIG_arg_fail(1)) SWIG_fail;
19867 {
19868 arg2 = (bool)(SWIG_As_bool(obj1));
19869 if (SWIG_arg_fail(2)) SWIG_fail;
19870 }
19871 {
19872 PyThreadState* __tstate = wxPyBeginAllowThreads();
19873 (arg1)->SetLoggingOff(arg2);
19874
19875 wxPyEndAllowThreads(__tstate);
19876 if (PyErr_Occurred()) SWIG_fail;
19877 }
19878 Py_INCREF(Py_None); resultobj = Py_None;
19879 return resultobj;
19880 fail:
19881 return NULL;
19882 }
19883
19884
19885 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19886 PyObject *resultobj;
19887 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19888 bool result;
19889 PyObject * obj0 = 0 ;
19890 char *kwnames[] = {
19891 (char *) "self", NULL
19892 };
19893
19894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19896 if (SWIG_arg_fail(1)) SWIG_fail;
19897 {
19898 PyThreadState* __tstate = wxPyBeginAllowThreads();
19899 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19900
19901 wxPyEndAllowThreads(__tstate);
19902 if (PyErr_Occurred()) SWIG_fail;
19903 }
19904 {
19905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19906 }
19907 return resultobj;
19908 fail:
19909 return NULL;
19910 }
19911
19912
19913 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19914 PyObject *resultobj;
19915 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19916 bool arg2 = (bool) true ;
19917 PyObject * obj0 = 0 ;
19918 PyObject * obj1 = 0 ;
19919 char *kwnames[] = {
19920 (char *) "self",(char *) "veto", NULL
19921 };
19922
19923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19925 if (SWIG_arg_fail(1)) SWIG_fail;
19926 if (obj1) {
19927 {
19928 arg2 = (bool)(SWIG_As_bool(obj1));
19929 if (SWIG_arg_fail(2)) SWIG_fail;
19930 }
19931 }
19932 {
19933 PyThreadState* __tstate = wxPyBeginAllowThreads();
19934 (arg1)->Veto(arg2);
19935
19936 wxPyEndAllowThreads(__tstate);
19937 if (PyErr_Occurred()) SWIG_fail;
19938 }
19939 Py_INCREF(Py_None); resultobj = Py_None;
19940 return resultobj;
19941 fail:
19942 return NULL;
19943 }
19944
19945
19946 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19947 PyObject *resultobj;
19948 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19949 bool arg2 ;
19950 PyObject * obj0 = 0 ;
19951 PyObject * obj1 = 0 ;
19952 char *kwnames[] = {
19953 (char *) "self",(char *) "canVeto", NULL
19954 };
19955
19956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19958 if (SWIG_arg_fail(1)) SWIG_fail;
19959 {
19960 arg2 = (bool)(SWIG_As_bool(obj1));
19961 if (SWIG_arg_fail(2)) SWIG_fail;
19962 }
19963 {
19964 PyThreadState* __tstate = wxPyBeginAllowThreads();
19965 (arg1)->SetCanVeto(arg2);
19966
19967 wxPyEndAllowThreads(__tstate);
19968 if (PyErr_Occurred()) SWIG_fail;
19969 }
19970 Py_INCREF(Py_None); resultobj = Py_None;
19971 return resultobj;
19972 fail:
19973 return NULL;
19974 }
19975
19976
19977 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19978 PyObject *resultobj;
19979 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19980 bool result;
19981 PyObject * obj0 = 0 ;
19982 char *kwnames[] = {
19983 (char *) "self", NULL
19984 };
19985
19986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19988 if (SWIG_arg_fail(1)) SWIG_fail;
19989 {
19990 PyThreadState* __tstate = wxPyBeginAllowThreads();
19991 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19992
19993 wxPyEndAllowThreads(__tstate);
19994 if (PyErr_Occurred()) SWIG_fail;
19995 }
19996 {
19997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19998 }
19999 return resultobj;
20000 fail:
20001 return NULL;
20002 }
20003
20004
20005 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20006 PyObject *resultobj;
20007 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20008 bool result;
20009 PyObject * obj0 = 0 ;
20010 char *kwnames[] = {
20011 (char *) "self", NULL
20012 };
20013
20014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20016 if (SWIG_arg_fail(1)) SWIG_fail;
20017 {
20018 PyThreadState* __tstate = wxPyBeginAllowThreads();
20019 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20020
20021 wxPyEndAllowThreads(__tstate);
20022 if (PyErr_Occurred()) SWIG_fail;
20023 }
20024 {
20025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20026 }
20027 return resultobj;
20028 fail:
20029 return NULL;
20030 }
20031
20032
20033 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20034 PyObject *obj;
20035 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20036 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20037 Py_INCREF(obj);
20038 return Py_BuildValue((char *)"");
20039 }
20040 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20041 PyObject *resultobj;
20042 int arg1 = (int) 0 ;
20043 bool arg2 = (bool) false ;
20044 wxShowEvent *result;
20045 PyObject * obj0 = 0 ;
20046 PyObject * obj1 = 0 ;
20047 char *kwnames[] = {
20048 (char *) "winid",(char *) "show", NULL
20049 };
20050
20051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20052 if (obj0) {
20053 {
20054 arg1 = (int)(SWIG_As_int(obj0));
20055 if (SWIG_arg_fail(1)) SWIG_fail;
20056 }
20057 }
20058 if (obj1) {
20059 {
20060 arg2 = (bool)(SWIG_As_bool(obj1));
20061 if (SWIG_arg_fail(2)) SWIG_fail;
20062 }
20063 }
20064 {
20065 PyThreadState* __tstate = wxPyBeginAllowThreads();
20066 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20067
20068 wxPyEndAllowThreads(__tstate);
20069 if (PyErr_Occurred()) SWIG_fail;
20070 }
20071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20072 return resultobj;
20073 fail:
20074 return NULL;
20075 }
20076
20077
20078 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20079 PyObject *resultobj;
20080 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20081 bool arg2 ;
20082 PyObject * obj0 = 0 ;
20083 PyObject * obj1 = 0 ;
20084 char *kwnames[] = {
20085 (char *) "self",(char *) "show", NULL
20086 };
20087
20088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20090 if (SWIG_arg_fail(1)) SWIG_fail;
20091 {
20092 arg2 = (bool)(SWIG_As_bool(obj1));
20093 if (SWIG_arg_fail(2)) SWIG_fail;
20094 }
20095 {
20096 PyThreadState* __tstate = wxPyBeginAllowThreads();
20097 (arg1)->SetShow(arg2);
20098
20099 wxPyEndAllowThreads(__tstate);
20100 if (PyErr_Occurred()) SWIG_fail;
20101 }
20102 Py_INCREF(Py_None); resultobj = Py_None;
20103 return resultobj;
20104 fail:
20105 return NULL;
20106 }
20107
20108
20109 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20110 PyObject *resultobj;
20111 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20112 bool result;
20113 PyObject * obj0 = 0 ;
20114 char *kwnames[] = {
20115 (char *) "self", NULL
20116 };
20117
20118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20120 if (SWIG_arg_fail(1)) SWIG_fail;
20121 {
20122 PyThreadState* __tstate = wxPyBeginAllowThreads();
20123 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20124
20125 wxPyEndAllowThreads(__tstate);
20126 if (PyErr_Occurred()) SWIG_fail;
20127 }
20128 {
20129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20130 }
20131 return resultobj;
20132 fail:
20133 return NULL;
20134 }
20135
20136
20137 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20138 PyObject *obj;
20139 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20140 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20141 Py_INCREF(obj);
20142 return Py_BuildValue((char *)"");
20143 }
20144 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20145 PyObject *resultobj;
20146 int arg1 = (int) 0 ;
20147 bool arg2 = (bool) true ;
20148 wxIconizeEvent *result;
20149 PyObject * obj0 = 0 ;
20150 PyObject * obj1 = 0 ;
20151 char *kwnames[] = {
20152 (char *) "id",(char *) "iconized", NULL
20153 };
20154
20155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20156 if (obj0) {
20157 {
20158 arg1 = (int)(SWIG_As_int(obj0));
20159 if (SWIG_arg_fail(1)) SWIG_fail;
20160 }
20161 }
20162 if (obj1) {
20163 {
20164 arg2 = (bool)(SWIG_As_bool(obj1));
20165 if (SWIG_arg_fail(2)) SWIG_fail;
20166 }
20167 }
20168 {
20169 PyThreadState* __tstate = wxPyBeginAllowThreads();
20170 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20171
20172 wxPyEndAllowThreads(__tstate);
20173 if (PyErr_Occurred()) SWIG_fail;
20174 }
20175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20183 PyObject *resultobj;
20184 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20185 bool result;
20186 PyObject * obj0 = 0 ;
20187 char *kwnames[] = {
20188 (char *) "self", NULL
20189 };
20190
20191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20193 if (SWIG_arg_fail(1)) SWIG_fail;
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 result = (bool)(arg1)->Iconized();
20197
20198 wxPyEndAllowThreads(__tstate);
20199 if (PyErr_Occurred()) SWIG_fail;
20200 }
20201 {
20202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20203 }
20204 return resultobj;
20205 fail:
20206 return NULL;
20207 }
20208
20209
20210 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20211 PyObject *obj;
20212 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20213 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20214 Py_INCREF(obj);
20215 return Py_BuildValue((char *)"");
20216 }
20217 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20218 PyObject *resultobj;
20219 int arg1 = (int) 0 ;
20220 wxMaximizeEvent *result;
20221 PyObject * obj0 = 0 ;
20222 char *kwnames[] = {
20223 (char *) "id", NULL
20224 };
20225
20226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20227 if (obj0) {
20228 {
20229 arg1 = (int)(SWIG_As_int(obj0));
20230 if (SWIG_arg_fail(1)) SWIG_fail;
20231 }
20232 }
20233 {
20234 PyThreadState* __tstate = wxPyBeginAllowThreads();
20235 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20236
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20248 PyObject *obj;
20249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20250 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20251 Py_INCREF(obj);
20252 return Py_BuildValue((char *)"");
20253 }
20254 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20255 PyObject *resultobj;
20256 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20257 wxPoint result;
20258 PyObject * obj0 = 0 ;
20259 char *kwnames[] = {
20260 (char *) "self", NULL
20261 };
20262
20263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20265 if (SWIG_arg_fail(1)) SWIG_fail;
20266 {
20267 PyThreadState* __tstate = wxPyBeginAllowThreads();
20268 result = (arg1)->GetPosition();
20269
20270 wxPyEndAllowThreads(__tstate);
20271 if (PyErr_Occurred()) SWIG_fail;
20272 }
20273 {
20274 wxPoint * resultptr;
20275 resultptr = new wxPoint((wxPoint &)(result));
20276 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20277 }
20278 return resultobj;
20279 fail:
20280 return NULL;
20281 }
20282
20283
20284 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20285 PyObject *resultobj;
20286 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20287 int result;
20288 PyObject * obj0 = 0 ;
20289 char *kwnames[] = {
20290 (char *) "self", NULL
20291 };
20292
20293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20295 if (SWIG_arg_fail(1)) SWIG_fail;
20296 {
20297 PyThreadState* __tstate = wxPyBeginAllowThreads();
20298 result = (int)(arg1)->GetNumberOfFiles();
20299
20300 wxPyEndAllowThreads(__tstate);
20301 if (PyErr_Occurred()) SWIG_fail;
20302 }
20303 {
20304 resultobj = SWIG_From_int((int)(result));
20305 }
20306 return resultobj;
20307 fail:
20308 return NULL;
20309 }
20310
20311
20312 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20313 PyObject *resultobj;
20314 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20315 PyObject *result;
20316 PyObject * obj0 = 0 ;
20317 char *kwnames[] = {
20318 (char *) "self", NULL
20319 };
20320
20321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20323 if (SWIG_arg_fail(1)) SWIG_fail;
20324 {
20325 PyThreadState* __tstate = wxPyBeginAllowThreads();
20326 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20327
20328 wxPyEndAllowThreads(__tstate);
20329 if (PyErr_Occurred()) SWIG_fail;
20330 }
20331 resultobj = result;
20332 return resultobj;
20333 fail:
20334 return NULL;
20335 }
20336
20337
20338 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20339 PyObject *obj;
20340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20341 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20342 Py_INCREF(obj);
20343 return Py_BuildValue((char *)"");
20344 }
20345 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20346 PyObject *resultobj;
20347 int arg1 = (int) 0 ;
20348 wxUpdateUIEvent *result;
20349 PyObject * obj0 = 0 ;
20350 char *kwnames[] = {
20351 (char *) "commandId", NULL
20352 };
20353
20354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",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 = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20364
20365 wxPyEndAllowThreads(__tstate);
20366 if (PyErr_Occurred()) SWIG_fail;
20367 }
20368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20369 return resultobj;
20370 fail:
20371 return NULL;
20372 }
20373
20374
20375 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20376 PyObject *resultobj;
20377 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20378 bool result;
20379 PyObject * obj0 = 0 ;
20380 char *kwnames[] = {
20381 (char *) "self", NULL
20382 };
20383
20384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20386 if (SWIG_arg_fail(1)) SWIG_fail;
20387 {
20388 PyThreadState* __tstate = wxPyBeginAllowThreads();
20389 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20390
20391 wxPyEndAllowThreads(__tstate);
20392 if (PyErr_Occurred()) SWIG_fail;
20393 }
20394 {
20395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20396 }
20397 return resultobj;
20398 fail:
20399 return NULL;
20400 }
20401
20402
20403 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20404 PyObject *resultobj;
20405 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20406 bool result;
20407 PyObject * obj0 = 0 ;
20408 char *kwnames[] = {
20409 (char *) "self", NULL
20410 };
20411
20412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20414 if (SWIG_arg_fail(1)) SWIG_fail;
20415 {
20416 PyThreadState* __tstate = wxPyBeginAllowThreads();
20417 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20418
20419 wxPyEndAllowThreads(__tstate);
20420 if (PyErr_Occurred()) SWIG_fail;
20421 }
20422 {
20423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20424 }
20425 return resultobj;
20426 fail:
20427 return NULL;
20428 }
20429
20430
20431 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20432 PyObject *resultobj;
20433 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20434 wxString result;
20435 PyObject * obj0 = 0 ;
20436 char *kwnames[] = {
20437 (char *) "self", NULL
20438 };
20439
20440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20442 if (SWIG_arg_fail(1)) SWIG_fail;
20443 {
20444 PyThreadState* __tstate = wxPyBeginAllowThreads();
20445 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20446
20447 wxPyEndAllowThreads(__tstate);
20448 if (PyErr_Occurred()) SWIG_fail;
20449 }
20450 {
20451 #if wxUSE_UNICODE
20452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20453 #else
20454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20455 #endif
20456 }
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20464 PyObject *resultobj;
20465 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20466 bool result;
20467 PyObject * obj0 = 0 ;
20468 char *kwnames[] = {
20469 (char *) "self", NULL
20470 };
20471
20472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20474 if (SWIG_arg_fail(1)) SWIG_fail;
20475 {
20476 PyThreadState* __tstate = wxPyBeginAllowThreads();
20477 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20478
20479 wxPyEndAllowThreads(__tstate);
20480 if (PyErr_Occurred()) SWIG_fail;
20481 }
20482 {
20483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20484 }
20485 return resultobj;
20486 fail:
20487 return NULL;
20488 }
20489
20490
20491 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20492 PyObject *resultobj;
20493 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20494 bool result;
20495 PyObject * obj0 = 0 ;
20496 char *kwnames[] = {
20497 (char *) "self", NULL
20498 };
20499
20500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20502 if (SWIG_arg_fail(1)) SWIG_fail;
20503 {
20504 PyThreadState* __tstate = wxPyBeginAllowThreads();
20505 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20506
20507 wxPyEndAllowThreads(__tstate);
20508 if (PyErr_Occurred()) SWIG_fail;
20509 }
20510 {
20511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20512 }
20513 return resultobj;
20514 fail:
20515 return NULL;
20516 }
20517
20518
20519 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20520 PyObject *resultobj;
20521 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20522 bool result;
20523 PyObject * obj0 = 0 ;
20524 char *kwnames[] = {
20525 (char *) "self", NULL
20526 };
20527
20528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20530 if (SWIG_arg_fail(1)) SWIG_fail;
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20534
20535 wxPyEndAllowThreads(__tstate);
20536 if (PyErr_Occurred()) SWIG_fail;
20537 }
20538 {
20539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20540 }
20541 return resultobj;
20542 fail:
20543 return NULL;
20544 }
20545
20546
20547 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20548 PyObject *resultobj;
20549 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20550 bool arg2 ;
20551 PyObject * obj0 = 0 ;
20552 PyObject * obj1 = 0 ;
20553 char *kwnames[] = {
20554 (char *) "self",(char *) "check", NULL
20555 };
20556
20557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20559 if (SWIG_arg_fail(1)) SWIG_fail;
20560 {
20561 arg2 = (bool)(SWIG_As_bool(obj1));
20562 if (SWIG_arg_fail(2)) SWIG_fail;
20563 }
20564 {
20565 PyThreadState* __tstate = wxPyBeginAllowThreads();
20566 (arg1)->Check(arg2);
20567
20568 wxPyEndAllowThreads(__tstate);
20569 if (PyErr_Occurred()) SWIG_fail;
20570 }
20571 Py_INCREF(Py_None); resultobj = Py_None;
20572 return resultobj;
20573 fail:
20574 return NULL;
20575 }
20576
20577
20578 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20579 PyObject *resultobj;
20580 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20581 bool arg2 ;
20582 PyObject * obj0 = 0 ;
20583 PyObject * obj1 = 0 ;
20584 char *kwnames[] = {
20585 (char *) "self",(char *) "enable", NULL
20586 };
20587
20588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20590 if (SWIG_arg_fail(1)) SWIG_fail;
20591 {
20592 arg2 = (bool)(SWIG_As_bool(obj1));
20593 if (SWIG_arg_fail(2)) SWIG_fail;
20594 }
20595 {
20596 PyThreadState* __tstate = wxPyBeginAllowThreads();
20597 (arg1)->Enable(arg2);
20598
20599 wxPyEndAllowThreads(__tstate);
20600 if (PyErr_Occurred()) SWIG_fail;
20601 }
20602 Py_INCREF(Py_None); resultobj = Py_None;
20603 return resultobj;
20604 fail:
20605 return NULL;
20606 }
20607
20608
20609 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20610 PyObject *resultobj;
20611 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20612 wxString *arg2 = 0 ;
20613 bool temp2 = false ;
20614 PyObject * obj0 = 0 ;
20615 PyObject * obj1 = 0 ;
20616 char *kwnames[] = {
20617 (char *) "self",(char *) "text", NULL
20618 };
20619
20620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20622 if (SWIG_arg_fail(1)) SWIG_fail;
20623 {
20624 arg2 = wxString_in_helper(obj1);
20625 if (arg2 == NULL) SWIG_fail;
20626 temp2 = true;
20627 }
20628 {
20629 PyThreadState* __tstate = wxPyBeginAllowThreads();
20630 (arg1)->SetText((wxString const &)*arg2);
20631
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 Py_INCREF(Py_None); resultobj = Py_None;
20636 {
20637 if (temp2)
20638 delete arg2;
20639 }
20640 return resultobj;
20641 fail:
20642 {
20643 if (temp2)
20644 delete arg2;
20645 }
20646 return NULL;
20647 }
20648
20649
20650 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20651 PyObject *resultobj;
20652 long arg1 ;
20653 PyObject * obj0 = 0 ;
20654 char *kwnames[] = {
20655 (char *) "updateInterval", NULL
20656 };
20657
20658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20659 {
20660 arg1 = (long)(SWIG_As_long(obj0));
20661 if (SWIG_arg_fail(1)) SWIG_fail;
20662 }
20663 {
20664 PyThreadState* __tstate = wxPyBeginAllowThreads();
20665 wxUpdateUIEvent::SetUpdateInterval(arg1);
20666
20667 wxPyEndAllowThreads(__tstate);
20668 if (PyErr_Occurred()) SWIG_fail;
20669 }
20670 Py_INCREF(Py_None); resultobj = Py_None;
20671 return resultobj;
20672 fail:
20673 return NULL;
20674 }
20675
20676
20677 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20678 PyObject *resultobj;
20679 long result;
20680 char *kwnames[] = {
20681 NULL
20682 };
20683
20684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20685 {
20686 PyThreadState* __tstate = wxPyBeginAllowThreads();
20687 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20688
20689 wxPyEndAllowThreads(__tstate);
20690 if (PyErr_Occurred()) SWIG_fail;
20691 }
20692 {
20693 resultobj = SWIG_From_long((long)(result));
20694 }
20695 return resultobj;
20696 fail:
20697 return NULL;
20698 }
20699
20700
20701 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20702 PyObject *resultobj;
20703 wxWindow *arg1 = (wxWindow *) 0 ;
20704 bool result;
20705 PyObject * obj0 = 0 ;
20706 char *kwnames[] = {
20707 (char *) "win", NULL
20708 };
20709
20710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20712 if (SWIG_arg_fail(1)) SWIG_fail;
20713 {
20714 PyThreadState* __tstate = wxPyBeginAllowThreads();
20715 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20716
20717 wxPyEndAllowThreads(__tstate);
20718 if (PyErr_Occurred()) SWIG_fail;
20719 }
20720 {
20721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20722 }
20723 return resultobj;
20724 fail:
20725 return NULL;
20726 }
20727
20728
20729 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20730 PyObject *resultobj;
20731 char *kwnames[] = {
20732 NULL
20733 };
20734
20735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20736 {
20737 PyThreadState* __tstate = wxPyBeginAllowThreads();
20738 wxUpdateUIEvent::ResetUpdateTime();
20739
20740 wxPyEndAllowThreads(__tstate);
20741 if (PyErr_Occurred()) SWIG_fail;
20742 }
20743 Py_INCREF(Py_None); resultobj = Py_None;
20744 return resultobj;
20745 fail:
20746 return NULL;
20747 }
20748
20749
20750 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20751 PyObject *resultobj;
20752 wxUpdateUIMode arg1 ;
20753 PyObject * obj0 = 0 ;
20754 char *kwnames[] = {
20755 (char *) "mode", NULL
20756 };
20757
20758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20759 {
20760 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20761 if (SWIG_arg_fail(1)) SWIG_fail;
20762 }
20763 {
20764 PyThreadState* __tstate = wxPyBeginAllowThreads();
20765 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20766
20767 wxPyEndAllowThreads(__tstate);
20768 if (PyErr_Occurred()) SWIG_fail;
20769 }
20770 Py_INCREF(Py_None); resultobj = Py_None;
20771 return resultobj;
20772 fail:
20773 return NULL;
20774 }
20775
20776
20777 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20778 PyObject *resultobj;
20779 wxUpdateUIMode result;
20780 char *kwnames[] = {
20781 NULL
20782 };
20783
20784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20785 {
20786 PyThreadState* __tstate = wxPyBeginAllowThreads();
20787 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20788
20789 wxPyEndAllowThreads(__tstate);
20790 if (PyErr_Occurred()) SWIG_fail;
20791 }
20792 resultobj = SWIG_From_int((result));
20793 return resultobj;
20794 fail:
20795 return NULL;
20796 }
20797
20798
20799 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20800 PyObject *obj;
20801 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20802 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20803 Py_INCREF(obj);
20804 return Py_BuildValue((char *)"");
20805 }
20806 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20807 PyObject *resultobj;
20808 wxSysColourChangedEvent *result;
20809 char *kwnames[] = {
20810 NULL
20811 };
20812
20813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20814 {
20815 PyThreadState* __tstate = wxPyBeginAllowThreads();
20816 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20817
20818 wxPyEndAllowThreads(__tstate);
20819 if (PyErr_Occurred()) SWIG_fail;
20820 }
20821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20822 return resultobj;
20823 fail:
20824 return NULL;
20825 }
20826
20827
20828 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20829 PyObject *obj;
20830 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20831 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20832 Py_INCREF(obj);
20833 return Py_BuildValue((char *)"");
20834 }
20835 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20836 PyObject *resultobj;
20837 int arg1 = (int) 0 ;
20838 wxWindow *arg2 = (wxWindow *) NULL ;
20839 wxMouseCaptureChangedEvent *result;
20840 PyObject * obj0 = 0 ;
20841 PyObject * obj1 = 0 ;
20842 char *kwnames[] = {
20843 (char *) "winid",(char *) "gainedCapture", NULL
20844 };
20845
20846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20847 if (obj0) {
20848 {
20849 arg1 = (int)(SWIG_As_int(obj0));
20850 if (SWIG_arg_fail(1)) SWIG_fail;
20851 }
20852 }
20853 if (obj1) {
20854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20855 if (SWIG_arg_fail(2)) SWIG_fail;
20856 }
20857 {
20858 PyThreadState* __tstate = wxPyBeginAllowThreads();
20859 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20860
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20865 return resultobj;
20866 fail:
20867 return NULL;
20868 }
20869
20870
20871 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20872 PyObject *resultobj;
20873 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20874 wxWindow *result;
20875 PyObject * obj0 = 0 ;
20876 char *kwnames[] = {
20877 (char *) "self", NULL
20878 };
20879
20880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20882 if (SWIG_arg_fail(1)) SWIG_fail;
20883 {
20884 PyThreadState* __tstate = wxPyBeginAllowThreads();
20885 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20886
20887 wxPyEndAllowThreads(__tstate);
20888 if (PyErr_Occurred()) SWIG_fail;
20889 }
20890 {
20891 resultobj = wxPyMake_wxObject(result, 0);
20892 }
20893 return resultobj;
20894 fail:
20895 return NULL;
20896 }
20897
20898
20899 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20900 PyObject *obj;
20901 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20902 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20903 Py_INCREF(obj);
20904 return Py_BuildValue((char *)"");
20905 }
20906 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20907 PyObject *resultobj;
20908 wxDisplayChangedEvent *result;
20909 char *kwnames[] = {
20910 NULL
20911 };
20912
20913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20914 {
20915 PyThreadState* __tstate = wxPyBeginAllowThreads();
20916 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20917
20918 wxPyEndAllowThreads(__tstate);
20919 if (PyErr_Occurred()) SWIG_fail;
20920 }
20921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20922 return resultobj;
20923 fail:
20924 return NULL;
20925 }
20926
20927
20928 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20929 PyObject *obj;
20930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20931 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20932 Py_INCREF(obj);
20933 return Py_BuildValue((char *)"");
20934 }
20935 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20936 PyObject *resultobj;
20937 int arg1 = (int) 0 ;
20938 wxPaletteChangedEvent *result;
20939 PyObject * obj0 = 0 ;
20940 char *kwnames[] = {
20941 (char *) "id", NULL
20942 };
20943
20944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20945 if (obj0) {
20946 {
20947 arg1 = (int)(SWIG_As_int(obj0));
20948 if (SWIG_arg_fail(1)) SWIG_fail;
20949 }
20950 }
20951 {
20952 PyThreadState* __tstate = wxPyBeginAllowThreads();
20953 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20954
20955 wxPyEndAllowThreads(__tstate);
20956 if (PyErr_Occurred()) SWIG_fail;
20957 }
20958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20959 return resultobj;
20960 fail:
20961 return NULL;
20962 }
20963
20964
20965 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20966 PyObject *resultobj;
20967 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20968 wxWindow *arg2 = (wxWindow *) 0 ;
20969 PyObject * obj0 = 0 ;
20970 PyObject * obj1 = 0 ;
20971 char *kwnames[] = {
20972 (char *) "self",(char *) "win", NULL
20973 };
20974
20975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20977 if (SWIG_arg_fail(1)) SWIG_fail;
20978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20979 if (SWIG_arg_fail(2)) SWIG_fail;
20980 {
20981 PyThreadState* __tstate = wxPyBeginAllowThreads();
20982 (arg1)->SetChangedWindow(arg2);
20983
20984 wxPyEndAllowThreads(__tstate);
20985 if (PyErr_Occurred()) SWIG_fail;
20986 }
20987 Py_INCREF(Py_None); resultobj = Py_None;
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20995 PyObject *resultobj;
20996 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20997 wxWindow *result;
20998 PyObject * obj0 = 0 ;
20999 char *kwnames[] = {
21000 (char *) "self", NULL
21001 };
21002
21003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21005 if (SWIG_arg_fail(1)) SWIG_fail;
21006 {
21007 PyThreadState* __tstate = wxPyBeginAllowThreads();
21008 result = (wxWindow *)(arg1)->GetChangedWindow();
21009
21010 wxPyEndAllowThreads(__tstate);
21011 if (PyErr_Occurred()) SWIG_fail;
21012 }
21013 {
21014 resultobj = wxPyMake_wxObject(result, 0);
21015 }
21016 return resultobj;
21017 fail:
21018 return NULL;
21019 }
21020
21021
21022 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21023 PyObject *obj;
21024 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21025 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21026 Py_INCREF(obj);
21027 return Py_BuildValue((char *)"");
21028 }
21029 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21030 PyObject *resultobj;
21031 int arg1 = (int) 0 ;
21032 wxQueryNewPaletteEvent *result;
21033 PyObject * obj0 = 0 ;
21034 char *kwnames[] = {
21035 (char *) "winid", NULL
21036 };
21037
21038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21039 if (obj0) {
21040 {
21041 arg1 = (int)(SWIG_As_int(obj0));
21042 if (SWIG_arg_fail(1)) SWIG_fail;
21043 }
21044 }
21045 {
21046 PyThreadState* __tstate = wxPyBeginAllowThreads();
21047 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21048
21049 wxPyEndAllowThreads(__tstate);
21050 if (PyErr_Occurred()) SWIG_fail;
21051 }
21052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21053 return resultobj;
21054 fail:
21055 return NULL;
21056 }
21057
21058
21059 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21060 PyObject *resultobj;
21061 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21062 bool arg2 ;
21063 PyObject * obj0 = 0 ;
21064 PyObject * obj1 = 0 ;
21065 char *kwnames[] = {
21066 (char *) "self",(char *) "realized", NULL
21067 };
21068
21069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21071 if (SWIG_arg_fail(1)) SWIG_fail;
21072 {
21073 arg2 = (bool)(SWIG_As_bool(obj1));
21074 if (SWIG_arg_fail(2)) SWIG_fail;
21075 }
21076 {
21077 PyThreadState* __tstate = wxPyBeginAllowThreads();
21078 (arg1)->SetPaletteRealized(arg2);
21079
21080 wxPyEndAllowThreads(__tstate);
21081 if (PyErr_Occurred()) SWIG_fail;
21082 }
21083 Py_INCREF(Py_None); resultobj = Py_None;
21084 return resultobj;
21085 fail:
21086 return NULL;
21087 }
21088
21089
21090 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21091 PyObject *resultobj;
21092 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21093 bool result;
21094 PyObject * obj0 = 0 ;
21095 char *kwnames[] = {
21096 (char *) "self", NULL
21097 };
21098
21099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21101 if (SWIG_arg_fail(1)) SWIG_fail;
21102 {
21103 PyThreadState* __tstate = wxPyBeginAllowThreads();
21104 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21105
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 {
21110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21111 }
21112 return resultobj;
21113 fail:
21114 return NULL;
21115 }
21116
21117
21118 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21119 PyObject *obj;
21120 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21121 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21122 Py_INCREF(obj);
21123 return Py_BuildValue((char *)"");
21124 }
21125 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21126 PyObject *resultobj;
21127 wxNavigationKeyEvent *result;
21128 char *kwnames[] = {
21129 NULL
21130 };
21131
21132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21133 {
21134 PyThreadState* __tstate = wxPyBeginAllowThreads();
21135 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21136
21137 wxPyEndAllowThreads(__tstate);
21138 if (PyErr_Occurred()) SWIG_fail;
21139 }
21140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21141 return resultobj;
21142 fail:
21143 return NULL;
21144 }
21145
21146
21147 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21148 PyObject *resultobj;
21149 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21150 bool result;
21151 PyObject * obj0 = 0 ;
21152 char *kwnames[] = {
21153 (char *) "self", NULL
21154 };
21155
21156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21158 if (SWIG_arg_fail(1)) SWIG_fail;
21159 {
21160 PyThreadState* __tstate = wxPyBeginAllowThreads();
21161 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21162
21163 wxPyEndAllowThreads(__tstate);
21164 if (PyErr_Occurred()) SWIG_fail;
21165 }
21166 {
21167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21168 }
21169 return resultobj;
21170 fail:
21171 return NULL;
21172 }
21173
21174
21175 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21176 PyObject *resultobj;
21177 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21178 bool arg2 ;
21179 PyObject * obj0 = 0 ;
21180 PyObject * obj1 = 0 ;
21181 char *kwnames[] = {
21182 (char *) "self",(char *) "forward", NULL
21183 };
21184
21185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21187 if (SWIG_arg_fail(1)) SWIG_fail;
21188 {
21189 arg2 = (bool)(SWIG_As_bool(obj1));
21190 if (SWIG_arg_fail(2)) SWIG_fail;
21191 }
21192 {
21193 PyThreadState* __tstate = wxPyBeginAllowThreads();
21194 (arg1)->SetDirection(arg2);
21195
21196 wxPyEndAllowThreads(__tstate);
21197 if (PyErr_Occurred()) SWIG_fail;
21198 }
21199 Py_INCREF(Py_None); resultobj = Py_None;
21200 return resultobj;
21201 fail:
21202 return NULL;
21203 }
21204
21205
21206 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21207 PyObject *resultobj;
21208 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21209 bool result;
21210 PyObject * obj0 = 0 ;
21211 char *kwnames[] = {
21212 (char *) "self", NULL
21213 };
21214
21215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21217 if (SWIG_arg_fail(1)) SWIG_fail;
21218 {
21219 PyThreadState* __tstate = wxPyBeginAllowThreads();
21220 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21221
21222 wxPyEndAllowThreads(__tstate);
21223 if (PyErr_Occurred()) SWIG_fail;
21224 }
21225 {
21226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21227 }
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21235 PyObject *resultobj;
21236 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21237 bool arg2 ;
21238 PyObject * obj0 = 0 ;
21239 PyObject * obj1 = 0 ;
21240 char *kwnames[] = {
21241 (char *) "self",(char *) "ischange", NULL
21242 };
21243
21244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21246 if (SWIG_arg_fail(1)) SWIG_fail;
21247 {
21248 arg2 = (bool)(SWIG_As_bool(obj1));
21249 if (SWIG_arg_fail(2)) SWIG_fail;
21250 }
21251 {
21252 PyThreadState* __tstate = wxPyBeginAllowThreads();
21253 (arg1)->SetWindowChange(arg2);
21254
21255 wxPyEndAllowThreads(__tstate);
21256 if (PyErr_Occurred()) SWIG_fail;
21257 }
21258 Py_INCREF(Py_None); resultobj = Py_None;
21259 return resultobj;
21260 fail:
21261 return NULL;
21262 }
21263
21264
21265 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21266 PyObject *resultobj;
21267 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21268 bool result;
21269 PyObject * obj0 = 0 ;
21270 char *kwnames[] = {
21271 (char *) "self", NULL
21272 };
21273
21274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21276 if (SWIG_arg_fail(1)) SWIG_fail;
21277 {
21278 PyThreadState* __tstate = wxPyBeginAllowThreads();
21279 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21280
21281 wxPyEndAllowThreads(__tstate);
21282 if (PyErr_Occurred()) SWIG_fail;
21283 }
21284 {
21285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21286 }
21287 return resultobj;
21288 fail:
21289 return NULL;
21290 }
21291
21292
21293 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21294 PyObject *resultobj;
21295 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21296 bool arg2 ;
21297 PyObject * obj0 = 0 ;
21298 PyObject * obj1 = 0 ;
21299 char *kwnames[] = {
21300 (char *) "self",(char *) "bIs", NULL
21301 };
21302
21303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21305 if (SWIG_arg_fail(1)) SWIG_fail;
21306 {
21307 arg2 = (bool)(SWIG_As_bool(obj1));
21308 if (SWIG_arg_fail(2)) SWIG_fail;
21309 }
21310 {
21311 PyThreadState* __tstate = wxPyBeginAllowThreads();
21312 (arg1)->SetFromTab(arg2);
21313
21314 wxPyEndAllowThreads(__tstate);
21315 if (PyErr_Occurred()) SWIG_fail;
21316 }
21317 Py_INCREF(Py_None); resultobj = Py_None;
21318 return resultobj;
21319 fail:
21320 return NULL;
21321 }
21322
21323
21324 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21325 PyObject *resultobj;
21326 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21327 long arg2 ;
21328 PyObject * obj0 = 0 ;
21329 PyObject * obj1 = 0 ;
21330 char *kwnames[] = {
21331 (char *) "self",(char *) "flags", NULL
21332 };
21333
21334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21336 if (SWIG_arg_fail(1)) SWIG_fail;
21337 {
21338 arg2 = (long)(SWIG_As_long(obj1));
21339 if (SWIG_arg_fail(2)) SWIG_fail;
21340 }
21341 {
21342 PyThreadState* __tstate = wxPyBeginAllowThreads();
21343 (arg1)->SetFlags(arg2);
21344
21345 wxPyEndAllowThreads(__tstate);
21346 if (PyErr_Occurred()) SWIG_fail;
21347 }
21348 Py_INCREF(Py_None); resultobj = Py_None;
21349 return resultobj;
21350 fail:
21351 return NULL;
21352 }
21353
21354
21355 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21356 PyObject *resultobj;
21357 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21358 wxWindow *result;
21359 PyObject * obj0 = 0 ;
21360 char *kwnames[] = {
21361 (char *) "self", NULL
21362 };
21363
21364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21366 if (SWIG_arg_fail(1)) SWIG_fail;
21367 {
21368 PyThreadState* __tstate = wxPyBeginAllowThreads();
21369 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21370
21371 wxPyEndAllowThreads(__tstate);
21372 if (PyErr_Occurred()) SWIG_fail;
21373 }
21374 {
21375 resultobj = wxPyMake_wxObject(result, 0);
21376 }
21377 return resultobj;
21378 fail:
21379 return NULL;
21380 }
21381
21382
21383 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21384 PyObject *resultobj;
21385 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21386 wxWindow *arg2 = (wxWindow *) 0 ;
21387 PyObject * obj0 = 0 ;
21388 PyObject * obj1 = 0 ;
21389 char *kwnames[] = {
21390 (char *) "self",(char *) "win", NULL
21391 };
21392
21393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21395 if (SWIG_arg_fail(1)) SWIG_fail;
21396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21397 if (SWIG_arg_fail(2)) SWIG_fail;
21398 {
21399 PyThreadState* __tstate = wxPyBeginAllowThreads();
21400 (arg1)->SetCurrentFocus(arg2);
21401
21402 wxPyEndAllowThreads(__tstate);
21403 if (PyErr_Occurred()) SWIG_fail;
21404 }
21405 Py_INCREF(Py_None); resultobj = Py_None;
21406 return resultobj;
21407 fail:
21408 return NULL;
21409 }
21410
21411
21412 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21413 PyObject *obj;
21414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21415 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21416 Py_INCREF(obj);
21417 return Py_BuildValue((char *)"");
21418 }
21419 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21420 PyObject *resultobj;
21421 wxWindow *arg1 = (wxWindow *) NULL ;
21422 wxWindowCreateEvent *result;
21423 PyObject * obj0 = 0 ;
21424 char *kwnames[] = {
21425 (char *) "win", NULL
21426 };
21427
21428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21429 if (obj0) {
21430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21431 if (SWIG_arg_fail(1)) SWIG_fail;
21432 }
21433 {
21434 PyThreadState* __tstate = wxPyBeginAllowThreads();
21435 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21436
21437 wxPyEndAllowThreads(__tstate);
21438 if (PyErr_Occurred()) SWIG_fail;
21439 }
21440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21448 PyObject *resultobj;
21449 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21450 wxWindow *result;
21451 PyObject * obj0 = 0 ;
21452 char *kwnames[] = {
21453 (char *) "self", NULL
21454 };
21455
21456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21458 if (SWIG_arg_fail(1)) SWIG_fail;
21459 {
21460 PyThreadState* __tstate = wxPyBeginAllowThreads();
21461 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21462
21463 wxPyEndAllowThreads(__tstate);
21464 if (PyErr_Occurred()) SWIG_fail;
21465 }
21466 {
21467 resultobj = wxPyMake_wxObject(result, 0);
21468 }
21469 return resultobj;
21470 fail:
21471 return NULL;
21472 }
21473
21474
21475 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21476 PyObject *obj;
21477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21478 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21479 Py_INCREF(obj);
21480 return Py_BuildValue((char *)"");
21481 }
21482 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21483 PyObject *resultobj;
21484 wxWindow *arg1 = (wxWindow *) NULL ;
21485 wxWindowDestroyEvent *result;
21486 PyObject * obj0 = 0 ;
21487 char *kwnames[] = {
21488 (char *) "win", NULL
21489 };
21490
21491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21492 if (obj0) {
21493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21494 if (SWIG_arg_fail(1)) SWIG_fail;
21495 }
21496 {
21497 PyThreadState* __tstate = wxPyBeginAllowThreads();
21498 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21499
21500 wxPyEndAllowThreads(__tstate);
21501 if (PyErr_Occurred()) SWIG_fail;
21502 }
21503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21504 return resultobj;
21505 fail:
21506 return NULL;
21507 }
21508
21509
21510 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21511 PyObject *resultobj;
21512 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21513 wxWindow *result;
21514 PyObject * obj0 = 0 ;
21515 char *kwnames[] = {
21516 (char *) "self", NULL
21517 };
21518
21519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21521 if (SWIG_arg_fail(1)) SWIG_fail;
21522 {
21523 PyThreadState* __tstate = wxPyBeginAllowThreads();
21524 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21525
21526 wxPyEndAllowThreads(__tstate);
21527 if (PyErr_Occurred()) SWIG_fail;
21528 }
21529 {
21530 resultobj = wxPyMake_wxObject(result, 0);
21531 }
21532 return resultobj;
21533 fail:
21534 return NULL;
21535 }
21536
21537
21538 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21539 PyObject *obj;
21540 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21541 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21542 Py_INCREF(obj);
21543 return Py_BuildValue((char *)"");
21544 }
21545 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21546 PyObject *resultobj;
21547 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21548 int arg2 = (int) 0 ;
21549 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21550 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21551 wxContextMenuEvent *result;
21552 wxPoint temp3 ;
21553 PyObject * obj0 = 0 ;
21554 PyObject * obj1 = 0 ;
21555 PyObject * obj2 = 0 ;
21556 char *kwnames[] = {
21557 (char *) "type",(char *) "winid",(char *) "pt", NULL
21558 };
21559
21560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21561 if (obj0) {
21562 {
21563 arg1 = (wxEventType)(SWIG_As_int(obj0));
21564 if (SWIG_arg_fail(1)) SWIG_fail;
21565 }
21566 }
21567 if (obj1) {
21568 {
21569 arg2 = (int)(SWIG_As_int(obj1));
21570 if (SWIG_arg_fail(2)) SWIG_fail;
21571 }
21572 }
21573 if (obj2) {
21574 {
21575 arg3 = &temp3;
21576 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21577 }
21578 }
21579 {
21580 PyThreadState* __tstate = wxPyBeginAllowThreads();
21581 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21582
21583 wxPyEndAllowThreads(__tstate);
21584 if (PyErr_Occurred()) SWIG_fail;
21585 }
21586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21587 return resultobj;
21588 fail:
21589 return NULL;
21590 }
21591
21592
21593 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21594 PyObject *resultobj;
21595 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21596 wxPoint *result;
21597 PyObject * obj0 = 0 ;
21598 char *kwnames[] = {
21599 (char *) "self", NULL
21600 };
21601
21602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21604 if (SWIG_arg_fail(1)) SWIG_fail;
21605 {
21606 PyThreadState* __tstate = wxPyBeginAllowThreads();
21607 {
21608 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21609 result = (wxPoint *) &_result_ref;
21610 }
21611
21612 wxPyEndAllowThreads(__tstate);
21613 if (PyErr_Occurred()) SWIG_fail;
21614 }
21615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21616 return resultobj;
21617 fail:
21618 return NULL;
21619 }
21620
21621
21622 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21623 PyObject *resultobj;
21624 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21625 wxPoint *arg2 = 0 ;
21626 wxPoint temp2 ;
21627 PyObject * obj0 = 0 ;
21628 PyObject * obj1 = 0 ;
21629 char *kwnames[] = {
21630 (char *) "self",(char *) "pos", NULL
21631 };
21632
21633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21635 if (SWIG_arg_fail(1)) SWIG_fail;
21636 {
21637 arg2 = &temp2;
21638 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21639 }
21640 {
21641 PyThreadState* __tstate = wxPyBeginAllowThreads();
21642 (arg1)->SetPosition((wxPoint const &)*arg2);
21643
21644 wxPyEndAllowThreads(__tstate);
21645 if (PyErr_Occurred()) SWIG_fail;
21646 }
21647 Py_INCREF(Py_None); resultobj = Py_None;
21648 return resultobj;
21649 fail:
21650 return NULL;
21651 }
21652
21653
21654 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21655 PyObject *obj;
21656 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21657 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21658 Py_INCREF(obj);
21659 return Py_BuildValue((char *)"");
21660 }
21661 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21662 PyObject *resultobj;
21663 wxIdleEvent *result;
21664 char *kwnames[] = {
21665 NULL
21666 };
21667
21668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21669 {
21670 PyThreadState* __tstate = wxPyBeginAllowThreads();
21671 result = (wxIdleEvent *)new wxIdleEvent();
21672
21673 wxPyEndAllowThreads(__tstate);
21674 if (PyErr_Occurred()) SWIG_fail;
21675 }
21676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21677 return resultobj;
21678 fail:
21679 return NULL;
21680 }
21681
21682
21683 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21684 PyObject *resultobj;
21685 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21686 bool arg2 = (bool) true ;
21687 PyObject * obj0 = 0 ;
21688 PyObject * obj1 = 0 ;
21689 char *kwnames[] = {
21690 (char *) "self",(char *) "needMore", NULL
21691 };
21692
21693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21695 if (SWIG_arg_fail(1)) SWIG_fail;
21696 if (obj1) {
21697 {
21698 arg2 = (bool)(SWIG_As_bool(obj1));
21699 if (SWIG_arg_fail(2)) SWIG_fail;
21700 }
21701 }
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 (arg1)->RequestMore(arg2);
21705
21706 wxPyEndAllowThreads(__tstate);
21707 if (PyErr_Occurred()) SWIG_fail;
21708 }
21709 Py_INCREF(Py_None); resultobj = Py_None;
21710 return resultobj;
21711 fail:
21712 return NULL;
21713 }
21714
21715
21716 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj;
21718 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21719 bool result;
21720 PyObject * obj0 = 0 ;
21721 char *kwnames[] = {
21722 (char *) "self", NULL
21723 };
21724
21725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21727 if (SWIG_arg_fail(1)) SWIG_fail;
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21731
21732 wxPyEndAllowThreads(__tstate);
21733 if (PyErr_Occurred()) SWIG_fail;
21734 }
21735 {
21736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21737 }
21738 return resultobj;
21739 fail:
21740 return NULL;
21741 }
21742
21743
21744 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21745 PyObject *resultobj;
21746 wxIdleMode arg1 ;
21747 PyObject * obj0 = 0 ;
21748 char *kwnames[] = {
21749 (char *) "mode", NULL
21750 };
21751
21752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21753 {
21754 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21755 if (SWIG_arg_fail(1)) SWIG_fail;
21756 }
21757 {
21758 PyThreadState* __tstate = wxPyBeginAllowThreads();
21759 wxIdleEvent::SetMode((wxIdleMode )arg1);
21760
21761 wxPyEndAllowThreads(__tstate);
21762 if (PyErr_Occurred()) SWIG_fail;
21763 }
21764 Py_INCREF(Py_None); resultobj = Py_None;
21765 return resultobj;
21766 fail:
21767 return NULL;
21768 }
21769
21770
21771 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21772 PyObject *resultobj;
21773 wxIdleMode result;
21774 char *kwnames[] = {
21775 NULL
21776 };
21777
21778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 result = (wxIdleMode)wxIdleEvent::GetMode();
21782
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 resultobj = SWIG_From_int((result));
21787 return resultobj;
21788 fail:
21789 return NULL;
21790 }
21791
21792
21793 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21794 PyObject *resultobj;
21795 wxWindow *arg1 = (wxWindow *) 0 ;
21796 bool result;
21797 PyObject * obj0 = 0 ;
21798 char *kwnames[] = {
21799 (char *) "win", NULL
21800 };
21801
21802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21804 if (SWIG_arg_fail(1)) SWIG_fail;
21805 {
21806 PyThreadState* __tstate = wxPyBeginAllowThreads();
21807 result = (bool)wxIdleEvent::CanSend(arg1);
21808
21809 wxPyEndAllowThreads(__tstate);
21810 if (PyErr_Occurred()) SWIG_fail;
21811 }
21812 {
21813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21814 }
21815 return resultobj;
21816 fail:
21817 return NULL;
21818 }
21819
21820
21821 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21822 PyObject *obj;
21823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21824 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21825 Py_INCREF(obj);
21826 return Py_BuildValue((char *)"");
21827 }
21828 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21829 PyObject *resultobj;
21830 int arg1 = (int) 0 ;
21831 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21832 wxPyEvent *result;
21833 PyObject * obj0 = 0 ;
21834 PyObject * obj1 = 0 ;
21835 char *kwnames[] = {
21836 (char *) "winid",(char *) "commandType", NULL
21837 };
21838
21839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21840 if (obj0) {
21841 {
21842 arg1 = (int)(SWIG_As_int(obj0));
21843 if (SWIG_arg_fail(1)) SWIG_fail;
21844 }
21845 }
21846 if (obj1) {
21847 {
21848 arg2 = (wxEventType)(SWIG_As_int(obj1));
21849 if (SWIG_arg_fail(2)) SWIG_fail;
21850 }
21851 }
21852 {
21853 PyThreadState* __tstate = wxPyBeginAllowThreads();
21854 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21855
21856 wxPyEndAllowThreads(__tstate);
21857 if (PyErr_Occurred()) SWIG_fail;
21858 }
21859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21860 return resultobj;
21861 fail:
21862 return NULL;
21863 }
21864
21865
21866 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21867 PyObject *resultobj;
21868 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21869 PyObject * obj0 = 0 ;
21870 char *kwnames[] = {
21871 (char *) "self", NULL
21872 };
21873
21874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21876 if (SWIG_arg_fail(1)) SWIG_fail;
21877 {
21878 PyThreadState* __tstate = wxPyBeginAllowThreads();
21879 delete arg1;
21880
21881 wxPyEndAllowThreads(__tstate);
21882 if (PyErr_Occurred()) SWIG_fail;
21883 }
21884 Py_INCREF(Py_None); resultobj = Py_None;
21885 return resultobj;
21886 fail:
21887 return NULL;
21888 }
21889
21890
21891 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21892 PyObject *resultobj;
21893 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21894 PyObject *arg2 = (PyObject *) 0 ;
21895 PyObject * obj0 = 0 ;
21896 PyObject * obj1 = 0 ;
21897 char *kwnames[] = {
21898 (char *) "self",(char *) "self", NULL
21899 };
21900
21901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21903 if (SWIG_arg_fail(1)) SWIG_fail;
21904 arg2 = obj1;
21905 {
21906 PyThreadState* __tstate = wxPyBeginAllowThreads();
21907 (arg1)->SetSelf(arg2);
21908
21909 wxPyEndAllowThreads(__tstate);
21910 if (PyErr_Occurred()) SWIG_fail;
21911 }
21912 Py_INCREF(Py_None); resultobj = Py_None;
21913 return resultobj;
21914 fail:
21915 return NULL;
21916 }
21917
21918
21919 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21920 PyObject *resultobj;
21921 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21922 PyObject *result;
21923 PyObject * obj0 = 0 ;
21924 char *kwnames[] = {
21925 (char *) "self", NULL
21926 };
21927
21928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21930 if (SWIG_arg_fail(1)) SWIG_fail;
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 result = (PyObject *)(arg1)->GetSelf();
21934
21935 wxPyEndAllowThreads(__tstate);
21936 if (PyErr_Occurred()) SWIG_fail;
21937 }
21938 resultobj = result;
21939 return resultobj;
21940 fail:
21941 return NULL;
21942 }
21943
21944
21945 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21946 PyObject *obj;
21947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21948 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21949 Py_INCREF(obj);
21950 return Py_BuildValue((char *)"");
21951 }
21952 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21953 PyObject *resultobj;
21954 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21955 int arg2 = (int) 0 ;
21956 wxPyCommandEvent *result;
21957 PyObject * obj0 = 0 ;
21958 PyObject * obj1 = 0 ;
21959 char *kwnames[] = {
21960 (char *) "commandType",(char *) "id", NULL
21961 };
21962
21963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21964 if (obj0) {
21965 {
21966 arg1 = (wxEventType)(SWIG_As_int(obj0));
21967 if (SWIG_arg_fail(1)) SWIG_fail;
21968 }
21969 }
21970 if (obj1) {
21971 {
21972 arg2 = (int)(SWIG_As_int(obj1));
21973 if (SWIG_arg_fail(2)) SWIG_fail;
21974 }
21975 }
21976 {
21977 PyThreadState* __tstate = wxPyBeginAllowThreads();
21978 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21979
21980 wxPyEndAllowThreads(__tstate);
21981 if (PyErr_Occurred()) SWIG_fail;
21982 }
21983 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21984 return resultobj;
21985 fail:
21986 return NULL;
21987 }
21988
21989
21990 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21991 PyObject *resultobj;
21992 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21993 PyObject * obj0 = 0 ;
21994 char *kwnames[] = {
21995 (char *) "self", NULL
21996 };
21997
21998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22000 if (SWIG_arg_fail(1)) SWIG_fail;
22001 {
22002 PyThreadState* __tstate = wxPyBeginAllowThreads();
22003 delete arg1;
22004
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 Py_INCREF(Py_None); resultobj = Py_None;
22009 return resultobj;
22010 fail:
22011 return NULL;
22012 }
22013
22014
22015 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22016 PyObject *resultobj;
22017 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22018 PyObject *arg2 = (PyObject *) 0 ;
22019 PyObject * obj0 = 0 ;
22020 PyObject * obj1 = 0 ;
22021 char *kwnames[] = {
22022 (char *) "self",(char *) "self", NULL
22023 };
22024
22025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22027 if (SWIG_arg_fail(1)) SWIG_fail;
22028 arg2 = obj1;
22029 {
22030 PyThreadState* __tstate = wxPyBeginAllowThreads();
22031 (arg1)->SetSelf(arg2);
22032
22033 wxPyEndAllowThreads(__tstate);
22034 if (PyErr_Occurred()) SWIG_fail;
22035 }
22036 Py_INCREF(Py_None); resultobj = Py_None;
22037 return resultobj;
22038 fail:
22039 return NULL;
22040 }
22041
22042
22043 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22044 PyObject *resultobj;
22045 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22046 PyObject *result;
22047 PyObject * obj0 = 0 ;
22048 char *kwnames[] = {
22049 (char *) "self", NULL
22050 };
22051
22052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22054 if (SWIG_arg_fail(1)) SWIG_fail;
22055 {
22056 PyThreadState* __tstate = wxPyBeginAllowThreads();
22057 result = (PyObject *)(arg1)->GetSelf();
22058
22059 wxPyEndAllowThreads(__tstate);
22060 if (PyErr_Occurred()) SWIG_fail;
22061 }
22062 resultobj = result;
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22070 PyObject *obj;
22071 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22072 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22073 Py_INCREF(obj);
22074 return Py_BuildValue((char *)"");
22075 }
22076 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22077 PyObject *resultobj;
22078 wxWindow *arg1 = (wxWindow *) 0 ;
22079 wxDateTime *arg2 = 0 ;
22080 wxEventType arg3 ;
22081 wxDateEvent *result;
22082 PyObject * obj0 = 0 ;
22083 PyObject * obj1 = 0 ;
22084 PyObject * obj2 = 0 ;
22085 char *kwnames[] = {
22086 (char *) "win",(char *) "dt",(char *) "type", NULL
22087 };
22088
22089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22091 if (SWIG_arg_fail(1)) SWIG_fail;
22092 {
22093 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22094 if (SWIG_arg_fail(2)) SWIG_fail;
22095 if (arg2 == NULL) {
22096 SWIG_null_ref("wxDateTime");
22097 }
22098 if (SWIG_arg_fail(2)) SWIG_fail;
22099 }
22100 {
22101 arg3 = (wxEventType)(SWIG_As_int(obj2));
22102 if (SWIG_arg_fail(3)) SWIG_fail;
22103 }
22104 {
22105 PyThreadState* __tstate = wxPyBeginAllowThreads();
22106 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22107
22108 wxPyEndAllowThreads(__tstate);
22109 if (PyErr_Occurred()) SWIG_fail;
22110 }
22111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22112 return resultobj;
22113 fail:
22114 return NULL;
22115 }
22116
22117
22118 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22119 PyObject *resultobj;
22120 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22121 wxDateTime *result;
22122 PyObject * obj0 = 0 ;
22123 char *kwnames[] = {
22124 (char *) "self", NULL
22125 };
22126
22127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22129 if (SWIG_arg_fail(1)) SWIG_fail;
22130 {
22131 PyThreadState* __tstate = wxPyBeginAllowThreads();
22132 {
22133 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22134 result = (wxDateTime *) &_result_ref;
22135 }
22136
22137 wxPyEndAllowThreads(__tstate);
22138 if (PyErr_Occurred()) SWIG_fail;
22139 }
22140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22141 return resultobj;
22142 fail:
22143 return NULL;
22144 }
22145
22146
22147 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22148 PyObject *resultobj;
22149 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22150 wxDateTime *arg2 = 0 ;
22151 PyObject * obj0 = 0 ;
22152 PyObject * obj1 = 0 ;
22153 char *kwnames[] = {
22154 (char *) "self",(char *) "date", NULL
22155 };
22156
22157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22159 if (SWIG_arg_fail(1)) SWIG_fail;
22160 {
22161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22162 if (SWIG_arg_fail(2)) SWIG_fail;
22163 if (arg2 == NULL) {
22164 SWIG_null_ref("wxDateTime");
22165 }
22166 if (SWIG_arg_fail(2)) SWIG_fail;
22167 }
22168 {
22169 PyThreadState* __tstate = wxPyBeginAllowThreads();
22170 (arg1)->SetDate((wxDateTime const &)*arg2);
22171
22172 wxPyEndAllowThreads(__tstate);
22173 if (PyErr_Occurred()) SWIG_fail;
22174 }
22175 Py_INCREF(Py_None); resultobj = Py_None;
22176 return resultobj;
22177 fail:
22178 return NULL;
22179 }
22180
22181
22182 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22183 PyObject *obj;
22184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22185 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22186 Py_INCREF(obj);
22187 return Py_BuildValue((char *)"");
22188 }
22189 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22190 PyObject *resultobj;
22191 wxPyApp *result;
22192 char *kwnames[] = {
22193 NULL
22194 };
22195
22196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22197 {
22198 PyThreadState* __tstate = wxPyBeginAllowThreads();
22199 result = (wxPyApp *)new_wxPyApp();
22200
22201 wxPyEndAllowThreads(__tstate);
22202 if (PyErr_Occurred()) SWIG_fail;
22203 }
22204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22205 return resultobj;
22206 fail:
22207 return NULL;
22208 }
22209
22210
22211 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22212 PyObject *resultobj;
22213 wxPyApp *arg1 = (wxPyApp *) 0 ;
22214 PyObject * obj0 = 0 ;
22215 char *kwnames[] = {
22216 (char *) "self", NULL
22217 };
22218
22219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22221 if (SWIG_arg_fail(1)) SWIG_fail;
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 delete arg1;
22225
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 Py_INCREF(Py_None); resultobj = Py_None;
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22237 PyObject *resultobj;
22238 wxPyApp *arg1 = (wxPyApp *) 0 ;
22239 PyObject *arg2 = (PyObject *) 0 ;
22240 PyObject *arg3 = (PyObject *) 0 ;
22241 PyObject * obj0 = 0 ;
22242 PyObject * obj1 = 0 ;
22243 PyObject * obj2 = 0 ;
22244 char *kwnames[] = {
22245 (char *) "self",(char *) "self",(char *) "_class", NULL
22246 };
22247
22248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22250 if (SWIG_arg_fail(1)) SWIG_fail;
22251 arg2 = obj1;
22252 arg3 = obj2;
22253 {
22254 PyThreadState* __tstate = wxPyBeginAllowThreads();
22255 (arg1)->_setCallbackInfo(arg2,arg3);
22256
22257 wxPyEndAllowThreads(__tstate);
22258 if (PyErr_Occurred()) SWIG_fail;
22259 }
22260 Py_INCREF(Py_None); resultobj = Py_None;
22261 return resultobj;
22262 fail:
22263 return NULL;
22264 }
22265
22266
22267 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22268 PyObject *resultobj;
22269 wxPyApp *arg1 = (wxPyApp *) 0 ;
22270 wxString result;
22271 PyObject * obj0 = 0 ;
22272 char *kwnames[] = {
22273 (char *) "self", NULL
22274 };
22275
22276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22278 if (SWIG_arg_fail(1)) SWIG_fail;
22279 {
22280 PyThreadState* __tstate = wxPyBeginAllowThreads();
22281 result = ((wxPyApp const *)arg1)->GetAppName();
22282
22283 wxPyEndAllowThreads(__tstate);
22284 if (PyErr_Occurred()) SWIG_fail;
22285 }
22286 {
22287 #if wxUSE_UNICODE
22288 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22289 #else
22290 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22291 #endif
22292 }
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22300 PyObject *resultobj;
22301 wxPyApp *arg1 = (wxPyApp *) 0 ;
22302 wxString *arg2 = 0 ;
22303 bool temp2 = false ;
22304 PyObject * obj0 = 0 ;
22305 PyObject * obj1 = 0 ;
22306 char *kwnames[] = {
22307 (char *) "self",(char *) "name", NULL
22308 };
22309
22310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22312 if (SWIG_arg_fail(1)) SWIG_fail;
22313 {
22314 arg2 = wxString_in_helper(obj1);
22315 if (arg2 == NULL) SWIG_fail;
22316 temp2 = true;
22317 }
22318 {
22319 PyThreadState* __tstate = wxPyBeginAllowThreads();
22320 (arg1)->SetAppName((wxString const &)*arg2);
22321
22322 wxPyEndAllowThreads(__tstate);
22323 if (PyErr_Occurred()) SWIG_fail;
22324 }
22325 Py_INCREF(Py_None); resultobj = Py_None;
22326 {
22327 if (temp2)
22328 delete arg2;
22329 }
22330 return resultobj;
22331 fail:
22332 {
22333 if (temp2)
22334 delete arg2;
22335 }
22336 return NULL;
22337 }
22338
22339
22340 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22341 PyObject *resultobj;
22342 wxPyApp *arg1 = (wxPyApp *) 0 ;
22343 wxString result;
22344 PyObject * obj0 = 0 ;
22345 char *kwnames[] = {
22346 (char *) "self", NULL
22347 };
22348
22349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22351 if (SWIG_arg_fail(1)) SWIG_fail;
22352 {
22353 PyThreadState* __tstate = wxPyBeginAllowThreads();
22354 result = ((wxPyApp const *)arg1)->GetClassName();
22355
22356 wxPyEndAllowThreads(__tstate);
22357 if (PyErr_Occurred()) SWIG_fail;
22358 }
22359 {
22360 #if wxUSE_UNICODE
22361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22362 #else
22363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22364 #endif
22365 }
22366 return resultobj;
22367 fail:
22368 return NULL;
22369 }
22370
22371
22372 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22373 PyObject *resultobj;
22374 wxPyApp *arg1 = (wxPyApp *) 0 ;
22375 wxString *arg2 = 0 ;
22376 bool temp2 = false ;
22377 PyObject * obj0 = 0 ;
22378 PyObject * obj1 = 0 ;
22379 char *kwnames[] = {
22380 (char *) "self",(char *) "name", NULL
22381 };
22382
22383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22385 if (SWIG_arg_fail(1)) SWIG_fail;
22386 {
22387 arg2 = wxString_in_helper(obj1);
22388 if (arg2 == NULL) SWIG_fail;
22389 temp2 = true;
22390 }
22391 {
22392 PyThreadState* __tstate = wxPyBeginAllowThreads();
22393 (arg1)->SetClassName((wxString const &)*arg2);
22394
22395 wxPyEndAllowThreads(__tstate);
22396 if (PyErr_Occurred()) SWIG_fail;
22397 }
22398 Py_INCREF(Py_None); resultobj = Py_None;
22399 {
22400 if (temp2)
22401 delete arg2;
22402 }
22403 return resultobj;
22404 fail:
22405 {
22406 if (temp2)
22407 delete arg2;
22408 }
22409 return NULL;
22410 }
22411
22412
22413 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22414 PyObject *resultobj;
22415 wxPyApp *arg1 = (wxPyApp *) 0 ;
22416 wxString *result;
22417 PyObject * obj0 = 0 ;
22418 char *kwnames[] = {
22419 (char *) "self", NULL
22420 };
22421
22422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22424 if (SWIG_arg_fail(1)) SWIG_fail;
22425 {
22426 PyThreadState* __tstate = wxPyBeginAllowThreads();
22427 {
22428 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22429 result = (wxString *) &_result_ref;
22430 }
22431
22432 wxPyEndAllowThreads(__tstate);
22433 if (PyErr_Occurred()) SWIG_fail;
22434 }
22435 {
22436 #if wxUSE_UNICODE
22437 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22438 #else
22439 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22440 #endif
22441 }
22442 return resultobj;
22443 fail:
22444 return NULL;
22445 }
22446
22447
22448 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22449 PyObject *resultobj;
22450 wxPyApp *arg1 = (wxPyApp *) 0 ;
22451 wxString *arg2 = 0 ;
22452 bool temp2 = false ;
22453 PyObject * obj0 = 0 ;
22454 PyObject * obj1 = 0 ;
22455 char *kwnames[] = {
22456 (char *) "self",(char *) "name", NULL
22457 };
22458
22459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22461 if (SWIG_arg_fail(1)) SWIG_fail;
22462 {
22463 arg2 = wxString_in_helper(obj1);
22464 if (arg2 == NULL) SWIG_fail;
22465 temp2 = true;
22466 }
22467 {
22468 PyThreadState* __tstate = wxPyBeginAllowThreads();
22469 (arg1)->SetVendorName((wxString const &)*arg2);
22470
22471 wxPyEndAllowThreads(__tstate);
22472 if (PyErr_Occurred()) SWIG_fail;
22473 }
22474 Py_INCREF(Py_None); resultobj = Py_None;
22475 {
22476 if (temp2)
22477 delete arg2;
22478 }
22479 return resultobj;
22480 fail:
22481 {
22482 if (temp2)
22483 delete arg2;
22484 }
22485 return NULL;
22486 }
22487
22488
22489 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22490 PyObject *resultobj;
22491 wxPyApp *arg1 = (wxPyApp *) 0 ;
22492 wxAppTraits *result;
22493 PyObject * obj0 = 0 ;
22494 char *kwnames[] = {
22495 (char *) "self", NULL
22496 };
22497
22498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22500 if (SWIG_arg_fail(1)) SWIG_fail;
22501 {
22502 PyThreadState* __tstate = wxPyBeginAllowThreads();
22503 result = (wxAppTraits *)(arg1)->GetTraits();
22504
22505 wxPyEndAllowThreads(__tstate);
22506 if (PyErr_Occurred()) SWIG_fail;
22507 }
22508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22509 return resultobj;
22510 fail:
22511 return NULL;
22512 }
22513
22514
22515 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22516 PyObject *resultobj;
22517 wxPyApp *arg1 = (wxPyApp *) 0 ;
22518 PyObject * obj0 = 0 ;
22519 char *kwnames[] = {
22520 (char *) "self", NULL
22521 };
22522
22523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22525 if (SWIG_arg_fail(1)) SWIG_fail;
22526 {
22527 PyThreadState* __tstate = wxPyBeginAllowThreads();
22528 (arg1)->ProcessPendingEvents();
22529
22530 wxPyEndAllowThreads(__tstate);
22531 if (PyErr_Occurred()) SWIG_fail;
22532 }
22533 Py_INCREF(Py_None); resultobj = Py_None;
22534 return resultobj;
22535 fail:
22536 return NULL;
22537 }
22538
22539
22540 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22541 PyObject *resultobj;
22542 wxPyApp *arg1 = (wxPyApp *) 0 ;
22543 bool arg2 = (bool) false ;
22544 bool result;
22545 PyObject * obj0 = 0 ;
22546 PyObject * obj1 = 0 ;
22547 char *kwnames[] = {
22548 (char *) "self",(char *) "onlyIfNeeded", NULL
22549 };
22550
22551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22553 if (SWIG_arg_fail(1)) SWIG_fail;
22554 if (obj1) {
22555 {
22556 arg2 = (bool)(SWIG_As_bool(obj1));
22557 if (SWIG_arg_fail(2)) SWIG_fail;
22558 }
22559 }
22560 {
22561 PyThreadState* __tstate = wxPyBeginAllowThreads();
22562 result = (bool)(arg1)->Yield(arg2);
22563
22564 wxPyEndAllowThreads(__tstate);
22565 if (PyErr_Occurred()) SWIG_fail;
22566 }
22567 {
22568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22569 }
22570 return resultobj;
22571 fail:
22572 return NULL;
22573 }
22574
22575
22576 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22577 PyObject *resultobj;
22578 wxPyApp *arg1 = (wxPyApp *) 0 ;
22579 PyObject * obj0 = 0 ;
22580 char *kwnames[] = {
22581 (char *) "self", NULL
22582 };
22583
22584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22586 if (SWIG_arg_fail(1)) SWIG_fail;
22587 {
22588 PyThreadState* __tstate = wxPyBeginAllowThreads();
22589 (arg1)->WakeUpIdle();
22590
22591 wxPyEndAllowThreads(__tstate);
22592 if (PyErr_Occurred()) SWIG_fail;
22593 }
22594 Py_INCREF(Py_None); resultobj = Py_None;
22595 return resultobj;
22596 fail:
22597 return NULL;
22598 }
22599
22600
22601 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22602 PyObject *resultobj;
22603 bool result;
22604 char *kwnames[] = {
22605 NULL
22606 };
22607
22608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22609 {
22610 PyThreadState* __tstate = wxPyBeginAllowThreads();
22611 result = (bool)wxPyApp::IsMainLoopRunning();
22612
22613 wxPyEndAllowThreads(__tstate);
22614 if (PyErr_Occurred()) SWIG_fail;
22615 }
22616 {
22617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22618 }
22619 return resultobj;
22620 fail:
22621 return NULL;
22622 }
22623
22624
22625 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22626 PyObject *resultobj;
22627 wxPyApp *arg1 = (wxPyApp *) 0 ;
22628 int result;
22629 PyObject * obj0 = 0 ;
22630 char *kwnames[] = {
22631 (char *) "self", NULL
22632 };
22633
22634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22636 if (SWIG_arg_fail(1)) SWIG_fail;
22637 {
22638 PyThreadState* __tstate = wxPyBeginAllowThreads();
22639 result = (int)(arg1)->MainLoop();
22640
22641 wxPyEndAllowThreads(__tstate);
22642 if (PyErr_Occurred()) SWIG_fail;
22643 }
22644 {
22645 resultobj = SWIG_From_int((int)(result));
22646 }
22647 return resultobj;
22648 fail:
22649 return NULL;
22650 }
22651
22652
22653 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22654 PyObject *resultobj;
22655 wxPyApp *arg1 = (wxPyApp *) 0 ;
22656 PyObject * obj0 = 0 ;
22657 char *kwnames[] = {
22658 (char *) "self", NULL
22659 };
22660
22661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22663 if (SWIG_arg_fail(1)) SWIG_fail;
22664 {
22665 PyThreadState* __tstate = wxPyBeginAllowThreads();
22666 (arg1)->Exit();
22667
22668 wxPyEndAllowThreads(__tstate);
22669 if (PyErr_Occurred()) SWIG_fail;
22670 }
22671 Py_INCREF(Py_None); resultobj = Py_None;
22672 return resultobj;
22673 fail:
22674 return NULL;
22675 }
22676
22677
22678 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22679 PyObject *resultobj;
22680 wxPyApp *arg1 = (wxPyApp *) 0 ;
22681 PyObject * obj0 = 0 ;
22682 char *kwnames[] = {
22683 (char *) "self", NULL
22684 };
22685
22686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22688 if (SWIG_arg_fail(1)) SWIG_fail;
22689 {
22690 PyThreadState* __tstate = wxPyBeginAllowThreads();
22691 (arg1)->ExitMainLoop();
22692
22693 wxPyEndAllowThreads(__tstate);
22694 if (PyErr_Occurred()) SWIG_fail;
22695 }
22696 Py_INCREF(Py_None); resultobj = Py_None;
22697 return resultobj;
22698 fail:
22699 return NULL;
22700 }
22701
22702
22703 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22704 PyObject *resultobj;
22705 wxPyApp *arg1 = (wxPyApp *) 0 ;
22706 bool result;
22707 PyObject * obj0 = 0 ;
22708 char *kwnames[] = {
22709 (char *) "self", NULL
22710 };
22711
22712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22714 if (SWIG_arg_fail(1)) SWIG_fail;
22715 {
22716 PyThreadState* __tstate = wxPyBeginAllowThreads();
22717 result = (bool)(arg1)->Pending();
22718
22719 wxPyEndAllowThreads(__tstate);
22720 if (PyErr_Occurred()) SWIG_fail;
22721 }
22722 {
22723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22724 }
22725 return resultobj;
22726 fail:
22727 return NULL;
22728 }
22729
22730
22731 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22732 PyObject *resultobj;
22733 wxPyApp *arg1 = (wxPyApp *) 0 ;
22734 bool result;
22735 PyObject * obj0 = 0 ;
22736 char *kwnames[] = {
22737 (char *) "self", NULL
22738 };
22739
22740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22742 if (SWIG_arg_fail(1)) SWIG_fail;
22743 {
22744 PyThreadState* __tstate = wxPyBeginAllowThreads();
22745 result = (bool)(arg1)->Dispatch();
22746
22747 wxPyEndAllowThreads(__tstate);
22748 if (PyErr_Occurred()) SWIG_fail;
22749 }
22750 {
22751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22752 }
22753 return resultobj;
22754 fail:
22755 return NULL;
22756 }
22757
22758
22759 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22760 PyObject *resultobj;
22761 wxPyApp *arg1 = (wxPyApp *) 0 ;
22762 bool result;
22763 PyObject * obj0 = 0 ;
22764 char *kwnames[] = {
22765 (char *) "self", NULL
22766 };
22767
22768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22770 if (SWIG_arg_fail(1)) SWIG_fail;
22771 {
22772 PyThreadState* __tstate = wxPyBeginAllowThreads();
22773 result = (bool)(arg1)->ProcessIdle();
22774
22775 wxPyEndAllowThreads(__tstate);
22776 if (PyErr_Occurred()) SWIG_fail;
22777 }
22778 {
22779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22780 }
22781 return resultobj;
22782 fail:
22783 return NULL;
22784 }
22785
22786
22787 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22788 PyObject *resultobj;
22789 wxPyApp *arg1 = (wxPyApp *) 0 ;
22790 wxWindow *arg2 = (wxWindow *) 0 ;
22791 wxIdleEvent *arg3 = 0 ;
22792 bool result;
22793 PyObject * obj0 = 0 ;
22794 PyObject * obj1 = 0 ;
22795 PyObject * obj2 = 0 ;
22796 char *kwnames[] = {
22797 (char *) "self",(char *) "win",(char *) "event", NULL
22798 };
22799
22800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22802 if (SWIG_arg_fail(1)) SWIG_fail;
22803 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22804 if (SWIG_arg_fail(2)) SWIG_fail;
22805 {
22806 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22807 if (SWIG_arg_fail(3)) SWIG_fail;
22808 if (arg3 == NULL) {
22809 SWIG_null_ref("wxIdleEvent");
22810 }
22811 if (SWIG_arg_fail(3)) SWIG_fail;
22812 }
22813 {
22814 PyThreadState* __tstate = wxPyBeginAllowThreads();
22815 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22816
22817 wxPyEndAllowThreads(__tstate);
22818 if (PyErr_Occurred()) SWIG_fail;
22819 }
22820 {
22821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22822 }
22823 return resultobj;
22824 fail:
22825 return NULL;
22826 }
22827
22828
22829 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22830 PyObject *resultobj;
22831 wxPyApp *arg1 = (wxPyApp *) 0 ;
22832 bool result;
22833 PyObject * obj0 = 0 ;
22834 char *kwnames[] = {
22835 (char *) "self", NULL
22836 };
22837
22838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22840 if (SWIG_arg_fail(1)) SWIG_fail;
22841 {
22842 PyThreadState* __tstate = wxPyBeginAllowThreads();
22843 result = (bool)((wxPyApp const *)arg1)->IsActive();
22844
22845 wxPyEndAllowThreads(__tstate);
22846 if (PyErr_Occurred()) SWIG_fail;
22847 }
22848 {
22849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22850 }
22851 return resultobj;
22852 fail:
22853 return NULL;
22854 }
22855
22856
22857 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22858 PyObject *resultobj;
22859 wxPyApp *arg1 = (wxPyApp *) 0 ;
22860 wxWindow *arg2 = (wxWindow *) 0 ;
22861 PyObject * obj0 = 0 ;
22862 PyObject * obj1 = 0 ;
22863 char *kwnames[] = {
22864 (char *) "self",(char *) "win", NULL
22865 };
22866
22867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22869 if (SWIG_arg_fail(1)) SWIG_fail;
22870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22871 if (SWIG_arg_fail(2)) SWIG_fail;
22872 {
22873 PyThreadState* __tstate = wxPyBeginAllowThreads();
22874 (arg1)->SetTopWindow(arg2);
22875
22876 wxPyEndAllowThreads(__tstate);
22877 if (PyErr_Occurred()) SWIG_fail;
22878 }
22879 Py_INCREF(Py_None); resultobj = Py_None;
22880 return resultobj;
22881 fail:
22882 return NULL;
22883 }
22884
22885
22886 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22887 PyObject *resultobj;
22888 wxPyApp *arg1 = (wxPyApp *) 0 ;
22889 wxWindow *result;
22890 PyObject * obj0 = 0 ;
22891 char *kwnames[] = {
22892 (char *) "self", NULL
22893 };
22894
22895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22897 if (SWIG_arg_fail(1)) SWIG_fail;
22898 {
22899 PyThreadState* __tstate = wxPyBeginAllowThreads();
22900 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22901
22902 wxPyEndAllowThreads(__tstate);
22903 if (PyErr_Occurred()) SWIG_fail;
22904 }
22905 {
22906 resultobj = wxPyMake_wxObject(result, 0);
22907 }
22908 return resultobj;
22909 fail:
22910 return NULL;
22911 }
22912
22913
22914 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22915 PyObject *resultobj;
22916 wxPyApp *arg1 = (wxPyApp *) 0 ;
22917 bool arg2 ;
22918 PyObject * obj0 = 0 ;
22919 PyObject * obj1 = 0 ;
22920 char *kwnames[] = {
22921 (char *) "self",(char *) "flag", NULL
22922 };
22923
22924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22926 if (SWIG_arg_fail(1)) SWIG_fail;
22927 {
22928 arg2 = (bool)(SWIG_As_bool(obj1));
22929 if (SWIG_arg_fail(2)) SWIG_fail;
22930 }
22931 {
22932 PyThreadState* __tstate = wxPyBeginAllowThreads();
22933 (arg1)->SetExitOnFrameDelete(arg2);
22934
22935 wxPyEndAllowThreads(__tstate);
22936 if (PyErr_Occurred()) SWIG_fail;
22937 }
22938 Py_INCREF(Py_None); resultobj = Py_None;
22939 return resultobj;
22940 fail:
22941 return NULL;
22942 }
22943
22944
22945 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22946 PyObject *resultobj;
22947 wxPyApp *arg1 = (wxPyApp *) 0 ;
22948 bool result;
22949 PyObject * obj0 = 0 ;
22950 char *kwnames[] = {
22951 (char *) "self", NULL
22952 };
22953
22954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22956 if (SWIG_arg_fail(1)) SWIG_fail;
22957 {
22958 PyThreadState* __tstate = wxPyBeginAllowThreads();
22959 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22960
22961 wxPyEndAllowThreads(__tstate);
22962 if (PyErr_Occurred()) SWIG_fail;
22963 }
22964 {
22965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22966 }
22967 return resultobj;
22968 fail:
22969 return NULL;
22970 }
22971
22972
22973 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22974 PyObject *resultobj;
22975 wxPyApp *arg1 = (wxPyApp *) 0 ;
22976 bool arg2 ;
22977 PyObject * obj0 = 0 ;
22978 PyObject * obj1 = 0 ;
22979 char *kwnames[] = {
22980 (char *) "self",(char *) "flag", NULL
22981 };
22982
22983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22985 if (SWIG_arg_fail(1)) SWIG_fail;
22986 {
22987 arg2 = (bool)(SWIG_As_bool(obj1));
22988 if (SWIG_arg_fail(2)) SWIG_fail;
22989 }
22990 {
22991 PyThreadState* __tstate = wxPyBeginAllowThreads();
22992 (arg1)->SetUseBestVisual(arg2);
22993
22994 wxPyEndAllowThreads(__tstate);
22995 if (PyErr_Occurred()) SWIG_fail;
22996 }
22997 Py_INCREF(Py_None); resultobj = Py_None;
22998 return resultobj;
22999 fail:
23000 return NULL;
23001 }
23002
23003
23004 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23005 PyObject *resultobj;
23006 wxPyApp *arg1 = (wxPyApp *) 0 ;
23007 bool result;
23008 PyObject * obj0 = 0 ;
23009 char *kwnames[] = {
23010 (char *) "self", NULL
23011 };
23012
23013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23015 if (SWIG_arg_fail(1)) SWIG_fail;
23016 {
23017 PyThreadState* __tstate = wxPyBeginAllowThreads();
23018 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23019
23020 wxPyEndAllowThreads(__tstate);
23021 if (PyErr_Occurred()) SWIG_fail;
23022 }
23023 {
23024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23025 }
23026 return resultobj;
23027 fail:
23028 return NULL;
23029 }
23030
23031
23032 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23033 PyObject *resultobj;
23034 wxPyApp *arg1 = (wxPyApp *) 0 ;
23035 int arg2 ;
23036 PyObject * obj0 = 0 ;
23037 PyObject * obj1 = 0 ;
23038 char *kwnames[] = {
23039 (char *) "self",(char *) "mode", NULL
23040 };
23041
23042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23044 if (SWIG_arg_fail(1)) SWIG_fail;
23045 {
23046 arg2 = (int)(SWIG_As_int(obj1));
23047 if (SWIG_arg_fail(2)) SWIG_fail;
23048 }
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 (arg1)->SetPrintMode(arg2);
23052
23053 wxPyEndAllowThreads(__tstate);
23054 if (PyErr_Occurred()) SWIG_fail;
23055 }
23056 Py_INCREF(Py_None); resultobj = Py_None;
23057 return resultobj;
23058 fail:
23059 return NULL;
23060 }
23061
23062
23063 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23064 PyObject *resultobj;
23065 wxPyApp *arg1 = (wxPyApp *) 0 ;
23066 int result;
23067 PyObject * obj0 = 0 ;
23068 char *kwnames[] = {
23069 (char *) "self", NULL
23070 };
23071
23072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23074 if (SWIG_arg_fail(1)) SWIG_fail;
23075 {
23076 PyThreadState* __tstate = wxPyBeginAllowThreads();
23077 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23078
23079 wxPyEndAllowThreads(__tstate);
23080 if (PyErr_Occurred()) SWIG_fail;
23081 }
23082 {
23083 resultobj = SWIG_From_int((int)(result));
23084 }
23085 return resultobj;
23086 fail:
23087 return NULL;
23088 }
23089
23090
23091 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23092 PyObject *resultobj;
23093 wxPyApp *arg1 = (wxPyApp *) 0 ;
23094 int arg2 ;
23095 PyObject * obj0 = 0 ;
23096 PyObject * obj1 = 0 ;
23097 char *kwnames[] = {
23098 (char *) "self",(char *) "mode", NULL
23099 };
23100
23101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23103 if (SWIG_arg_fail(1)) SWIG_fail;
23104 {
23105 arg2 = (int)(SWIG_As_int(obj1));
23106 if (SWIG_arg_fail(2)) SWIG_fail;
23107 }
23108 {
23109 PyThreadState* __tstate = wxPyBeginAllowThreads();
23110 (arg1)->SetAssertMode(arg2);
23111
23112 wxPyEndAllowThreads(__tstate);
23113 if (PyErr_Occurred()) SWIG_fail;
23114 }
23115 Py_INCREF(Py_None); resultobj = Py_None;
23116 return resultobj;
23117 fail:
23118 return NULL;
23119 }
23120
23121
23122 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23123 PyObject *resultobj;
23124 wxPyApp *arg1 = (wxPyApp *) 0 ;
23125 int result;
23126 PyObject * obj0 = 0 ;
23127 char *kwnames[] = {
23128 (char *) "self", NULL
23129 };
23130
23131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23133 if (SWIG_arg_fail(1)) SWIG_fail;
23134 {
23135 PyThreadState* __tstate = wxPyBeginAllowThreads();
23136 result = (int)(arg1)->GetAssertMode();
23137
23138 wxPyEndAllowThreads(__tstate);
23139 if (PyErr_Occurred()) SWIG_fail;
23140 }
23141 {
23142 resultobj = SWIG_From_int((int)(result));
23143 }
23144 return resultobj;
23145 fail:
23146 return NULL;
23147 }
23148
23149
23150 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23151 PyObject *resultobj;
23152 bool result;
23153 char *kwnames[] = {
23154 NULL
23155 };
23156
23157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23158 {
23159 PyThreadState* __tstate = wxPyBeginAllowThreads();
23160 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23161
23162 wxPyEndAllowThreads(__tstate);
23163 if (PyErr_Occurred()) SWIG_fail;
23164 }
23165 {
23166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23167 }
23168 return resultobj;
23169 fail:
23170 return NULL;
23171 }
23172
23173
23174 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23175 PyObject *resultobj;
23176 long result;
23177 char *kwnames[] = {
23178 NULL
23179 };
23180
23181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23182 {
23183 PyThreadState* __tstate = wxPyBeginAllowThreads();
23184 result = (long)wxPyApp::GetMacAboutMenuItemId();
23185
23186 wxPyEndAllowThreads(__tstate);
23187 if (PyErr_Occurred()) SWIG_fail;
23188 }
23189 {
23190 resultobj = SWIG_From_long((long)(result));
23191 }
23192 return resultobj;
23193 fail:
23194 return NULL;
23195 }
23196
23197
23198 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23199 PyObject *resultobj;
23200 long result;
23201 char *kwnames[] = {
23202 NULL
23203 };
23204
23205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23206 {
23207 PyThreadState* __tstate = wxPyBeginAllowThreads();
23208 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23209
23210 wxPyEndAllowThreads(__tstate);
23211 if (PyErr_Occurred()) SWIG_fail;
23212 }
23213 {
23214 resultobj = SWIG_From_long((long)(result));
23215 }
23216 return resultobj;
23217 fail:
23218 return NULL;
23219 }
23220
23221
23222 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23223 PyObject *resultobj;
23224 long result;
23225 char *kwnames[] = {
23226 NULL
23227 };
23228
23229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23230 {
23231 PyThreadState* __tstate = wxPyBeginAllowThreads();
23232 result = (long)wxPyApp::GetMacExitMenuItemId();
23233
23234 wxPyEndAllowThreads(__tstate);
23235 if (PyErr_Occurred()) SWIG_fail;
23236 }
23237 {
23238 resultobj = SWIG_From_long((long)(result));
23239 }
23240 return resultobj;
23241 fail:
23242 return NULL;
23243 }
23244
23245
23246 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23247 PyObject *resultobj;
23248 wxString result;
23249 char *kwnames[] = {
23250 NULL
23251 };
23252
23253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23254 {
23255 PyThreadState* __tstate = wxPyBeginAllowThreads();
23256 result = wxPyApp::GetMacHelpMenuTitleName();
23257
23258 wxPyEndAllowThreads(__tstate);
23259 if (PyErr_Occurred()) SWIG_fail;
23260 }
23261 {
23262 #if wxUSE_UNICODE
23263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23264 #else
23265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23266 #endif
23267 }
23268 return resultobj;
23269 fail:
23270 return NULL;
23271 }
23272
23273
23274 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23275 PyObject *resultobj;
23276 bool arg1 ;
23277 PyObject * obj0 = 0 ;
23278 char *kwnames[] = {
23279 (char *) "val", NULL
23280 };
23281
23282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23283 {
23284 arg1 = (bool)(SWIG_As_bool(obj0));
23285 if (SWIG_arg_fail(1)) SWIG_fail;
23286 }
23287 {
23288 PyThreadState* __tstate = wxPyBeginAllowThreads();
23289 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23290
23291 wxPyEndAllowThreads(__tstate);
23292 if (PyErr_Occurred()) SWIG_fail;
23293 }
23294 Py_INCREF(Py_None); resultobj = Py_None;
23295 return resultobj;
23296 fail:
23297 return NULL;
23298 }
23299
23300
23301 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23302 PyObject *resultobj;
23303 long arg1 ;
23304 PyObject * obj0 = 0 ;
23305 char *kwnames[] = {
23306 (char *) "val", NULL
23307 };
23308
23309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23310 {
23311 arg1 = (long)(SWIG_As_long(obj0));
23312 if (SWIG_arg_fail(1)) SWIG_fail;
23313 }
23314 {
23315 PyThreadState* __tstate = wxPyBeginAllowThreads();
23316 wxPyApp::SetMacAboutMenuItemId(arg1);
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_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23329 PyObject *resultobj;
23330 long arg1 ;
23331 PyObject * obj0 = 0 ;
23332 char *kwnames[] = {
23333 (char *) "val", NULL
23334 };
23335
23336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23337 {
23338 arg1 = (long)(SWIG_As_long(obj0));
23339 if (SWIG_arg_fail(1)) SWIG_fail;
23340 }
23341 {
23342 PyThreadState* __tstate = wxPyBeginAllowThreads();
23343 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23344
23345 wxPyEndAllowThreads(__tstate);
23346 if (PyErr_Occurred()) SWIG_fail;
23347 }
23348 Py_INCREF(Py_None); resultobj = Py_None;
23349 return resultobj;
23350 fail:
23351 return NULL;
23352 }
23353
23354
23355 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23356 PyObject *resultobj;
23357 long arg1 ;
23358 PyObject * obj0 = 0 ;
23359 char *kwnames[] = {
23360 (char *) "val", NULL
23361 };
23362
23363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23364 {
23365 arg1 = (long)(SWIG_As_long(obj0));
23366 if (SWIG_arg_fail(1)) SWIG_fail;
23367 }
23368 {
23369 PyThreadState* __tstate = wxPyBeginAllowThreads();
23370 wxPyApp::SetMacExitMenuItemId(arg1);
23371
23372 wxPyEndAllowThreads(__tstate);
23373 if (PyErr_Occurred()) SWIG_fail;
23374 }
23375 Py_INCREF(Py_None); resultobj = Py_None;
23376 return resultobj;
23377 fail:
23378 return NULL;
23379 }
23380
23381
23382 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23383 PyObject *resultobj;
23384 wxString *arg1 = 0 ;
23385 bool temp1 = false ;
23386 PyObject * obj0 = 0 ;
23387 char *kwnames[] = {
23388 (char *) "val", NULL
23389 };
23390
23391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23392 {
23393 arg1 = wxString_in_helper(obj0);
23394 if (arg1 == NULL) SWIG_fail;
23395 temp1 = true;
23396 }
23397 {
23398 PyThreadState* __tstate = wxPyBeginAllowThreads();
23399 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23400
23401 wxPyEndAllowThreads(__tstate);
23402 if (PyErr_Occurred()) SWIG_fail;
23403 }
23404 Py_INCREF(Py_None); resultobj = Py_None;
23405 {
23406 if (temp1)
23407 delete arg1;
23408 }
23409 return resultobj;
23410 fail:
23411 {
23412 if (temp1)
23413 delete arg1;
23414 }
23415 return NULL;
23416 }
23417
23418
23419 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23420 PyObject *resultobj;
23421 wxPyApp *arg1 = (wxPyApp *) 0 ;
23422 PyObject * obj0 = 0 ;
23423 char *kwnames[] = {
23424 (char *) "self", NULL
23425 };
23426
23427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23429 if (SWIG_arg_fail(1)) SWIG_fail;
23430 {
23431 PyThreadState* __tstate = wxPyBeginAllowThreads();
23432 (arg1)->_BootstrapApp();
23433
23434 wxPyEndAllowThreads(__tstate);
23435 if (PyErr_Occurred()) SWIG_fail;
23436 }
23437 Py_INCREF(Py_None); resultobj = Py_None;
23438 return resultobj;
23439 fail:
23440 return NULL;
23441 }
23442
23443
23444 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23445 PyObject *resultobj;
23446 int result;
23447 char *kwnames[] = {
23448 NULL
23449 };
23450
23451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23452 {
23453 PyThreadState* __tstate = wxPyBeginAllowThreads();
23454 result = (int)PyApp_GetComCtl32Version();
23455
23456 wxPyEndAllowThreads(__tstate);
23457 if (PyErr_Occurred()) SWIG_fail;
23458 }
23459 {
23460 resultobj = SWIG_From_int((int)(result));
23461 }
23462 return resultobj;
23463 fail:
23464 return NULL;
23465 }
23466
23467
23468 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23469 PyObject *obj;
23470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23471 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23472 Py_INCREF(obj);
23473 return Py_BuildValue((char *)"");
23474 }
23475 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23476 PyObject *resultobj;
23477 char *kwnames[] = {
23478 NULL
23479 };
23480
23481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 wxExit();
23485
23486 wxPyEndAllowThreads(__tstate);
23487 if (PyErr_Occurred()) SWIG_fail;
23488 }
23489 Py_INCREF(Py_None); resultobj = Py_None;
23490 return resultobj;
23491 fail:
23492 return NULL;
23493 }
23494
23495
23496 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23497 PyObject *resultobj;
23498 bool result;
23499 char *kwnames[] = {
23500 NULL
23501 };
23502
23503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23504 {
23505 PyThreadState* __tstate = wxPyBeginAllowThreads();
23506 result = (bool)wxYield();
23507
23508 wxPyEndAllowThreads(__tstate);
23509 if (PyErr_Occurred()) SWIG_fail;
23510 }
23511 {
23512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23513 }
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23521 PyObject *resultobj;
23522 bool result;
23523 char *kwnames[] = {
23524 NULL
23525 };
23526
23527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23528 {
23529 PyThreadState* __tstate = wxPyBeginAllowThreads();
23530 result = (bool)wxYieldIfNeeded();
23531
23532 wxPyEndAllowThreads(__tstate);
23533 if (PyErr_Occurred()) SWIG_fail;
23534 }
23535 {
23536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23537 }
23538 return resultobj;
23539 fail:
23540 return NULL;
23541 }
23542
23543
23544 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23545 PyObject *resultobj;
23546 wxWindow *arg1 = (wxWindow *) NULL ;
23547 bool arg2 = (bool) false ;
23548 bool result;
23549 PyObject * obj0 = 0 ;
23550 PyObject * obj1 = 0 ;
23551 char *kwnames[] = {
23552 (char *) "win",(char *) "onlyIfNeeded", NULL
23553 };
23554
23555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23556 if (obj0) {
23557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23558 if (SWIG_arg_fail(1)) SWIG_fail;
23559 }
23560 if (obj1) {
23561 {
23562 arg2 = (bool)(SWIG_As_bool(obj1));
23563 if (SWIG_arg_fail(2)) SWIG_fail;
23564 }
23565 }
23566 {
23567 PyThreadState* __tstate = wxPyBeginAllowThreads();
23568 result = (bool)wxSafeYield(arg1,arg2);
23569
23570 wxPyEndAllowThreads(__tstate);
23571 if (PyErr_Occurred()) SWIG_fail;
23572 }
23573 {
23574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23575 }
23576 return resultobj;
23577 fail:
23578 return NULL;
23579 }
23580
23581
23582 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23583 PyObject *resultobj;
23584 char *kwnames[] = {
23585 NULL
23586 };
23587
23588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23589 {
23590 PyThreadState* __tstate = wxPyBeginAllowThreads();
23591 wxWakeUpIdle();
23592
23593 wxPyEndAllowThreads(__tstate);
23594 if (PyErr_Occurred()) SWIG_fail;
23595 }
23596 Py_INCREF(Py_None); resultobj = Py_None;
23597 return resultobj;
23598 fail:
23599 return NULL;
23600 }
23601
23602
23603 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23604 PyObject *resultobj;
23605 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23606 wxEvent *arg2 = 0 ;
23607 PyObject * obj0 = 0 ;
23608 PyObject * obj1 = 0 ;
23609 char *kwnames[] = {
23610 (char *) "dest",(char *) "event", NULL
23611 };
23612
23613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23615 if (SWIG_arg_fail(1)) SWIG_fail;
23616 {
23617 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23618 if (SWIG_arg_fail(2)) SWIG_fail;
23619 if (arg2 == NULL) {
23620 SWIG_null_ref("wxEvent");
23621 }
23622 if (SWIG_arg_fail(2)) SWIG_fail;
23623 }
23624 {
23625 PyThreadState* __tstate = wxPyBeginAllowThreads();
23626 wxPostEvent(arg1,*arg2);
23627
23628 wxPyEndAllowThreads(__tstate);
23629 if (PyErr_Occurred()) SWIG_fail;
23630 }
23631 Py_INCREF(Py_None); resultobj = Py_None;
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23639 PyObject *resultobj;
23640 char *kwnames[] = {
23641 NULL
23642 };
23643
23644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23645 {
23646 PyThreadState* __tstate = wxPyBeginAllowThreads();
23647 wxApp_CleanUp();
23648
23649 wxPyEndAllowThreads(__tstate);
23650 if (PyErr_Occurred()) SWIG_fail;
23651 }
23652 Py_INCREF(Py_None); resultobj = Py_None;
23653 return resultobj;
23654 fail:
23655 return NULL;
23656 }
23657
23658
23659 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23660 PyObject *resultobj;
23661 wxPyApp *result;
23662 char *kwnames[] = {
23663 NULL
23664 };
23665
23666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23667 {
23668 PyThreadState* __tstate = wxPyBeginAllowThreads();
23669 result = (wxPyApp *)wxPyGetApp();
23670
23671 wxPyEndAllowThreads(__tstate);
23672 if (PyErr_Occurred()) SWIG_fail;
23673 }
23674 {
23675 resultobj = wxPyMake_wxObject(result, 0);
23676 }
23677 return resultobj;
23678 fail:
23679 return NULL;
23680 }
23681
23682
23683 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23684 PyObject *resultobj;
23685 char *arg1 = (char *) 0 ;
23686 PyObject * obj0 = 0 ;
23687 char *kwnames[] = {
23688 (char *) "encoding", NULL
23689 };
23690
23691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23692 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23693 SWIG_arg_fail(1);SWIG_fail;
23694 }
23695 {
23696 PyThreadState* __tstate = wxPyBeginAllowThreads();
23697 wxSetDefaultPyEncoding((char const *)arg1);
23698
23699 wxPyEndAllowThreads(__tstate);
23700 if (PyErr_Occurred()) SWIG_fail;
23701 }
23702 Py_INCREF(Py_None); resultobj = Py_None;
23703 return resultobj;
23704 fail:
23705 return NULL;
23706 }
23707
23708
23709 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23710 PyObject *resultobj;
23711 char *result;
23712 char *kwnames[] = {
23713 NULL
23714 };
23715
23716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23717 {
23718 PyThreadState* __tstate = wxPyBeginAllowThreads();
23719 result = (char *)wxGetDefaultPyEncoding();
23720
23721 wxPyEndAllowThreads(__tstate);
23722 if (PyErr_Occurred()) SWIG_fail;
23723 }
23724 resultobj = SWIG_FromCharPtr(result);
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23732 PyObject *resultobj;
23733 wxEventLoop *result;
23734 char *kwnames[] = {
23735 NULL
23736 };
23737
23738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23739 {
23740 PyThreadState* __tstate = wxPyBeginAllowThreads();
23741 result = (wxEventLoop *)new wxEventLoop();
23742
23743 wxPyEndAllowThreads(__tstate);
23744 if (PyErr_Occurred()) SWIG_fail;
23745 }
23746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23747 return resultobj;
23748 fail:
23749 return NULL;
23750 }
23751
23752
23753 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23754 PyObject *resultobj;
23755 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23756 PyObject * obj0 = 0 ;
23757 char *kwnames[] = {
23758 (char *) "self", NULL
23759 };
23760
23761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23763 if (SWIG_arg_fail(1)) SWIG_fail;
23764 {
23765 PyThreadState* __tstate = wxPyBeginAllowThreads();
23766 delete arg1;
23767
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 Py_INCREF(Py_None); resultobj = Py_None;
23772 return resultobj;
23773 fail:
23774 return NULL;
23775 }
23776
23777
23778 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23779 PyObject *resultobj;
23780 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23781 int result;
23782 PyObject * obj0 = 0 ;
23783 char *kwnames[] = {
23784 (char *) "self", NULL
23785 };
23786
23787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23789 if (SWIG_arg_fail(1)) SWIG_fail;
23790 {
23791 PyThreadState* __tstate = wxPyBeginAllowThreads();
23792 result = (int)(arg1)->Run();
23793
23794 wxPyEndAllowThreads(__tstate);
23795 if (PyErr_Occurred()) SWIG_fail;
23796 }
23797 {
23798 resultobj = SWIG_From_int((int)(result));
23799 }
23800 return resultobj;
23801 fail:
23802 return NULL;
23803 }
23804
23805
23806 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23807 PyObject *resultobj;
23808 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23809 int arg2 = (int) 0 ;
23810 PyObject * obj0 = 0 ;
23811 PyObject * obj1 = 0 ;
23812 char *kwnames[] = {
23813 (char *) "self",(char *) "rc", NULL
23814 };
23815
23816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23818 if (SWIG_arg_fail(1)) SWIG_fail;
23819 if (obj1) {
23820 {
23821 arg2 = (int)(SWIG_As_int(obj1));
23822 if (SWIG_arg_fail(2)) SWIG_fail;
23823 }
23824 }
23825 {
23826 PyThreadState* __tstate = wxPyBeginAllowThreads();
23827 (arg1)->Exit(arg2);
23828
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 Py_INCREF(Py_None); resultobj = Py_None;
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23840 PyObject *resultobj;
23841 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23842 bool result;
23843 PyObject * obj0 = 0 ;
23844 char *kwnames[] = {
23845 (char *) "self", NULL
23846 };
23847
23848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23850 if (SWIG_arg_fail(1)) SWIG_fail;
23851 {
23852 PyThreadState* __tstate = wxPyBeginAllowThreads();
23853 result = (bool)((wxEventLoop const *)arg1)->Pending();
23854
23855 wxPyEndAllowThreads(__tstate);
23856 if (PyErr_Occurred()) SWIG_fail;
23857 }
23858 {
23859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23860 }
23861 return resultobj;
23862 fail:
23863 return NULL;
23864 }
23865
23866
23867 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23868 PyObject *resultobj;
23869 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23870 bool result;
23871 PyObject * obj0 = 0 ;
23872 char *kwnames[] = {
23873 (char *) "self", NULL
23874 };
23875
23876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23878 if (SWIG_arg_fail(1)) SWIG_fail;
23879 {
23880 PyThreadState* __tstate = wxPyBeginAllowThreads();
23881 result = (bool)(arg1)->Dispatch();
23882
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 {
23887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23888 }
23889 return resultobj;
23890 fail:
23891 return NULL;
23892 }
23893
23894
23895 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23896 PyObject *resultobj;
23897 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23898 bool result;
23899 PyObject * obj0 = 0 ;
23900 char *kwnames[] = {
23901 (char *) "self", NULL
23902 };
23903
23904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23906 if (SWIG_arg_fail(1)) SWIG_fail;
23907 {
23908 PyThreadState* __tstate = wxPyBeginAllowThreads();
23909 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23910
23911 wxPyEndAllowThreads(__tstate);
23912 if (PyErr_Occurred()) SWIG_fail;
23913 }
23914 {
23915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23916 }
23917 return resultobj;
23918 fail:
23919 return NULL;
23920 }
23921
23922
23923 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23924 PyObject *resultobj;
23925 wxEventLoop *result;
23926 char *kwnames[] = {
23927 NULL
23928 };
23929
23930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23931 {
23932 PyThreadState* __tstate = wxPyBeginAllowThreads();
23933 result = (wxEventLoop *)wxEventLoop::GetActive();
23934
23935 wxPyEndAllowThreads(__tstate);
23936 if (PyErr_Occurred()) SWIG_fail;
23937 }
23938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23939 return resultobj;
23940 fail:
23941 return NULL;
23942 }
23943
23944
23945 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23946 PyObject *resultobj;
23947 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23948 PyObject * obj0 = 0 ;
23949 char *kwnames[] = {
23950 (char *) "loop", NULL
23951 };
23952
23953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23955 if (SWIG_arg_fail(1)) SWIG_fail;
23956 {
23957 PyThreadState* __tstate = wxPyBeginAllowThreads();
23958 wxEventLoop::SetActive(arg1);
23959
23960 wxPyEndAllowThreads(__tstate);
23961 if (PyErr_Occurred()) SWIG_fail;
23962 }
23963 Py_INCREF(Py_None); resultobj = Py_None;
23964 return resultobj;
23965 fail:
23966 return NULL;
23967 }
23968
23969
23970 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23971 PyObject *obj;
23972 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23973 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23974 Py_INCREF(obj);
23975 return Py_BuildValue((char *)"");
23976 }
23977 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23978 PyObject *resultobj;
23979 int arg1 = (int) 0 ;
23980 int arg2 = (int) 0 ;
23981 int arg3 = (int) 0 ;
23982 wxAcceleratorEntry *result;
23983 PyObject * obj0 = 0 ;
23984 PyObject * obj1 = 0 ;
23985 PyObject * obj2 = 0 ;
23986 char *kwnames[] = {
23987 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23988 };
23989
23990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23991 if (obj0) {
23992 {
23993 arg1 = (int)(SWIG_As_int(obj0));
23994 if (SWIG_arg_fail(1)) SWIG_fail;
23995 }
23996 }
23997 if (obj1) {
23998 {
23999 arg2 = (int)(SWIG_As_int(obj1));
24000 if (SWIG_arg_fail(2)) SWIG_fail;
24001 }
24002 }
24003 if (obj2) {
24004 {
24005 arg3 = (int)(SWIG_As_int(obj2));
24006 if (SWIG_arg_fail(3)) SWIG_fail;
24007 }
24008 }
24009 {
24010 PyThreadState* __tstate = wxPyBeginAllowThreads();
24011 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24012
24013 wxPyEndAllowThreads(__tstate);
24014 if (PyErr_Occurred()) SWIG_fail;
24015 }
24016 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24017 return resultobj;
24018 fail:
24019 return NULL;
24020 }
24021
24022
24023 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24024 PyObject *resultobj;
24025 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24026 PyObject * obj0 = 0 ;
24027 char *kwnames[] = {
24028 (char *) "self", NULL
24029 };
24030
24031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24033 if (SWIG_arg_fail(1)) SWIG_fail;
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 delete arg1;
24037
24038 wxPyEndAllowThreads(__tstate);
24039 if (PyErr_Occurred()) SWIG_fail;
24040 }
24041 Py_INCREF(Py_None); resultobj = Py_None;
24042 return resultobj;
24043 fail:
24044 return NULL;
24045 }
24046
24047
24048 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24049 PyObject *resultobj;
24050 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24051 int arg2 ;
24052 int arg3 ;
24053 int arg4 ;
24054 PyObject * obj0 = 0 ;
24055 PyObject * obj1 = 0 ;
24056 PyObject * obj2 = 0 ;
24057 PyObject * obj3 = 0 ;
24058 char *kwnames[] = {
24059 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24060 };
24061
24062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24064 if (SWIG_arg_fail(1)) SWIG_fail;
24065 {
24066 arg2 = (int)(SWIG_As_int(obj1));
24067 if (SWIG_arg_fail(2)) SWIG_fail;
24068 }
24069 {
24070 arg3 = (int)(SWIG_As_int(obj2));
24071 if (SWIG_arg_fail(3)) SWIG_fail;
24072 }
24073 {
24074 arg4 = (int)(SWIG_As_int(obj3));
24075 if (SWIG_arg_fail(4)) SWIG_fail;
24076 }
24077 {
24078 PyThreadState* __tstate = wxPyBeginAllowThreads();
24079 (arg1)->Set(arg2,arg3,arg4);
24080
24081 wxPyEndAllowThreads(__tstate);
24082 if (PyErr_Occurred()) SWIG_fail;
24083 }
24084 Py_INCREF(Py_None); resultobj = Py_None;
24085 return resultobj;
24086 fail:
24087 return NULL;
24088 }
24089
24090
24091 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24092 PyObject *resultobj;
24093 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24094 int result;
24095 PyObject * obj0 = 0 ;
24096 char *kwnames[] = {
24097 (char *) "self", NULL
24098 };
24099
24100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24102 if (SWIG_arg_fail(1)) SWIG_fail;
24103 {
24104 PyThreadState* __tstate = wxPyBeginAllowThreads();
24105 result = (int)(arg1)->GetFlags();
24106
24107 wxPyEndAllowThreads(__tstate);
24108 if (PyErr_Occurred()) SWIG_fail;
24109 }
24110 {
24111 resultobj = SWIG_From_int((int)(result));
24112 }
24113 return resultobj;
24114 fail:
24115 return NULL;
24116 }
24117
24118
24119 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24120 PyObject *resultobj;
24121 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24122 int result;
24123 PyObject * obj0 = 0 ;
24124 char *kwnames[] = {
24125 (char *) "self", NULL
24126 };
24127
24128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24130 if (SWIG_arg_fail(1)) SWIG_fail;
24131 {
24132 PyThreadState* __tstate = wxPyBeginAllowThreads();
24133 result = (int)(arg1)->GetKeyCode();
24134
24135 wxPyEndAllowThreads(__tstate);
24136 if (PyErr_Occurred()) SWIG_fail;
24137 }
24138 {
24139 resultobj = SWIG_From_int((int)(result));
24140 }
24141 return resultobj;
24142 fail:
24143 return NULL;
24144 }
24145
24146
24147 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24148 PyObject *resultobj;
24149 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24150 int result;
24151 PyObject * obj0 = 0 ;
24152 char *kwnames[] = {
24153 (char *) "self", NULL
24154 };
24155
24156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24158 if (SWIG_arg_fail(1)) SWIG_fail;
24159 {
24160 PyThreadState* __tstate = wxPyBeginAllowThreads();
24161 result = (int)(arg1)->GetCommand();
24162
24163 wxPyEndAllowThreads(__tstate);
24164 if (PyErr_Occurred()) SWIG_fail;
24165 }
24166 {
24167 resultobj = SWIG_From_int((int)(result));
24168 }
24169 return resultobj;
24170 fail:
24171 return NULL;
24172 }
24173
24174
24175 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24176 PyObject *obj;
24177 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24178 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24179 Py_INCREF(obj);
24180 return Py_BuildValue((char *)"");
24181 }
24182 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24183 PyObject *resultobj;
24184 int arg1 ;
24185 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24186 wxAcceleratorTable *result;
24187 PyObject * obj0 = 0 ;
24188 char *kwnames[] = {
24189 (char *) "n", NULL
24190 };
24191
24192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24193 {
24194 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24195 if (arg2) arg1 = PyList_Size(obj0);
24196 else arg1 = 0;
24197 }
24198 {
24199 PyThreadState* __tstate = wxPyBeginAllowThreads();
24200 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24201
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24206 {
24207 delete [] arg2;
24208 }
24209 return resultobj;
24210 fail:
24211 {
24212 delete [] arg2;
24213 }
24214 return NULL;
24215 }
24216
24217
24218 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24219 PyObject *resultobj;
24220 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24221 PyObject * obj0 = 0 ;
24222 char *kwnames[] = {
24223 (char *) "self", NULL
24224 };
24225
24226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24228 if (SWIG_arg_fail(1)) SWIG_fail;
24229 {
24230 PyThreadState* __tstate = wxPyBeginAllowThreads();
24231 delete arg1;
24232
24233 wxPyEndAllowThreads(__tstate);
24234 if (PyErr_Occurred()) SWIG_fail;
24235 }
24236 Py_INCREF(Py_None); resultobj = Py_None;
24237 return resultobj;
24238 fail:
24239 return NULL;
24240 }
24241
24242
24243 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24244 PyObject *resultobj;
24245 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24246 bool result;
24247 PyObject * obj0 = 0 ;
24248 char *kwnames[] = {
24249 (char *) "self", NULL
24250 };
24251
24252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24254 if (SWIG_arg_fail(1)) SWIG_fail;
24255 {
24256 PyThreadState* __tstate = wxPyBeginAllowThreads();
24257 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24258
24259 wxPyEndAllowThreads(__tstate);
24260 if (PyErr_Occurred()) SWIG_fail;
24261 }
24262 {
24263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24264 }
24265 return resultobj;
24266 fail:
24267 return NULL;
24268 }
24269
24270
24271 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24272 PyObject *obj;
24273 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24274 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24275 Py_INCREF(obj);
24276 return Py_BuildValue((char *)"");
24277 }
24278 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24279 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24280 return 1;
24281 }
24282
24283
24284 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24285 PyObject *pyobj;
24286
24287 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24288 return pyobj;
24289 }
24290
24291
24292 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24293 PyObject *resultobj;
24294 wxString *arg1 = 0 ;
24295 wxAcceleratorEntry *result;
24296 bool temp1 = false ;
24297 PyObject * obj0 = 0 ;
24298 char *kwnames[] = {
24299 (char *) "label", NULL
24300 };
24301
24302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24303 {
24304 arg1 = wxString_in_helper(obj0);
24305 if (arg1 == NULL) SWIG_fail;
24306 temp1 = true;
24307 }
24308 {
24309 PyThreadState* __tstate = wxPyBeginAllowThreads();
24310 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24311
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24316 {
24317 if (temp1)
24318 delete arg1;
24319 }
24320 return resultobj;
24321 fail:
24322 {
24323 if (temp1)
24324 delete arg1;
24325 }
24326 return NULL;
24327 }
24328
24329
24330 static int _wrap_PanelNameStr_set(PyObject *) {
24331 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24332 return 1;
24333 }
24334
24335
24336 static PyObject *_wrap_PanelNameStr_get(void) {
24337 PyObject *pyobj;
24338
24339 {
24340 #if wxUSE_UNICODE
24341 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24342 #else
24343 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24344 #endif
24345 }
24346 return pyobj;
24347 }
24348
24349
24350 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj;
24352 wxVisualAttributes *result;
24353 char *kwnames[] = {
24354 NULL
24355 };
24356
24357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24358 {
24359 PyThreadState* __tstate = wxPyBeginAllowThreads();
24360 result = (wxVisualAttributes *)new_wxVisualAttributes();
24361
24362 wxPyEndAllowThreads(__tstate);
24363 if (PyErr_Occurred()) SWIG_fail;
24364 }
24365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24366 return resultobj;
24367 fail:
24368 return NULL;
24369 }
24370
24371
24372 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24373 PyObject *resultobj;
24374 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24375 PyObject * obj0 = 0 ;
24376 char *kwnames[] = {
24377 (char *) "self", NULL
24378 };
24379
24380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24382 if (SWIG_arg_fail(1)) SWIG_fail;
24383 {
24384 PyThreadState* __tstate = wxPyBeginAllowThreads();
24385 delete_wxVisualAttributes(arg1);
24386
24387 wxPyEndAllowThreads(__tstate);
24388 if (PyErr_Occurred()) SWIG_fail;
24389 }
24390 Py_INCREF(Py_None); resultobj = Py_None;
24391 return resultobj;
24392 fail:
24393 return NULL;
24394 }
24395
24396
24397 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24398 PyObject *resultobj;
24399 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24400 wxFont *arg2 = (wxFont *) 0 ;
24401 PyObject * obj0 = 0 ;
24402 PyObject * obj1 = 0 ;
24403 char *kwnames[] = {
24404 (char *) "self",(char *) "font", NULL
24405 };
24406
24407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24409 if (SWIG_arg_fail(1)) SWIG_fail;
24410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24411 if (SWIG_arg_fail(2)) SWIG_fail;
24412 if (arg1) (arg1)->font = *arg2;
24413
24414 Py_INCREF(Py_None); resultobj = Py_None;
24415 return resultobj;
24416 fail:
24417 return NULL;
24418 }
24419
24420
24421 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24422 PyObject *resultobj;
24423 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24424 wxFont *result;
24425 PyObject * obj0 = 0 ;
24426 char *kwnames[] = {
24427 (char *) "self", NULL
24428 };
24429
24430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24432 if (SWIG_arg_fail(1)) SWIG_fail;
24433 result = (wxFont *)& ((arg1)->font);
24434
24435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24436 return resultobj;
24437 fail:
24438 return NULL;
24439 }
24440
24441
24442 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24443 PyObject *resultobj;
24444 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24445 wxColour *arg2 = (wxColour *) 0 ;
24446 PyObject * obj0 = 0 ;
24447 PyObject * obj1 = 0 ;
24448 char *kwnames[] = {
24449 (char *) "self",(char *) "colFg", NULL
24450 };
24451
24452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24454 if (SWIG_arg_fail(1)) SWIG_fail;
24455 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24456 if (SWIG_arg_fail(2)) SWIG_fail;
24457 if (arg1) (arg1)->colFg = *arg2;
24458
24459 Py_INCREF(Py_None); resultobj = Py_None;
24460 return resultobj;
24461 fail:
24462 return NULL;
24463 }
24464
24465
24466 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24467 PyObject *resultobj;
24468 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24469 wxColour *result;
24470 PyObject * obj0 = 0 ;
24471 char *kwnames[] = {
24472 (char *) "self", NULL
24473 };
24474
24475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24477 if (SWIG_arg_fail(1)) SWIG_fail;
24478 result = (wxColour *)& ((arg1)->colFg);
24479
24480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24481 return resultobj;
24482 fail:
24483 return NULL;
24484 }
24485
24486
24487 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24488 PyObject *resultobj;
24489 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24490 wxColour *arg2 = (wxColour *) 0 ;
24491 PyObject * obj0 = 0 ;
24492 PyObject * obj1 = 0 ;
24493 char *kwnames[] = {
24494 (char *) "self",(char *) "colBg", NULL
24495 };
24496
24497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24499 if (SWIG_arg_fail(1)) SWIG_fail;
24500 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24501 if (SWIG_arg_fail(2)) SWIG_fail;
24502 if (arg1) (arg1)->colBg = *arg2;
24503
24504 Py_INCREF(Py_None); resultobj = Py_None;
24505 return resultobj;
24506 fail:
24507 return NULL;
24508 }
24509
24510
24511 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24512 PyObject *resultobj;
24513 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24514 wxColour *result;
24515 PyObject * obj0 = 0 ;
24516 char *kwnames[] = {
24517 (char *) "self", NULL
24518 };
24519
24520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24522 if (SWIG_arg_fail(1)) SWIG_fail;
24523 result = (wxColour *)& ((arg1)->colBg);
24524
24525 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24533 PyObject *obj;
24534 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24535 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24536 Py_INCREF(obj);
24537 return Py_BuildValue((char *)"");
24538 }
24539 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24540 PyObject *resultobj;
24541 wxWindow *arg1 = (wxWindow *) 0 ;
24542 int arg2 = (int) (int)-1 ;
24543 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24544 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24545 wxSize const &arg4_defvalue = wxDefaultSize ;
24546 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24547 long arg5 = (long) 0 ;
24548 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24549 wxString *arg6 = (wxString *) &arg6_defvalue ;
24550 wxWindow *result;
24551 wxPoint temp3 ;
24552 wxSize temp4 ;
24553 bool temp6 = false ;
24554 PyObject * obj0 = 0 ;
24555 PyObject * obj1 = 0 ;
24556 PyObject * obj2 = 0 ;
24557 PyObject * obj3 = 0 ;
24558 PyObject * obj4 = 0 ;
24559 PyObject * obj5 = 0 ;
24560 char *kwnames[] = {
24561 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24562 };
24563
24564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24566 if (SWIG_arg_fail(1)) SWIG_fail;
24567 if (obj1) {
24568 {
24569 arg2 = (int const)(SWIG_As_int(obj1));
24570 if (SWIG_arg_fail(2)) SWIG_fail;
24571 }
24572 }
24573 if (obj2) {
24574 {
24575 arg3 = &temp3;
24576 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24577 }
24578 }
24579 if (obj3) {
24580 {
24581 arg4 = &temp4;
24582 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24583 }
24584 }
24585 if (obj4) {
24586 {
24587 arg5 = (long)(SWIG_As_long(obj4));
24588 if (SWIG_arg_fail(5)) SWIG_fail;
24589 }
24590 }
24591 if (obj5) {
24592 {
24593 arg6 = wxString_in_helper(obj5);
24594 if (arg6 == NULL) SWIG_fail;
24595 temp6 = true;
24596 }
24597 }
24598 {
24599 if (!wxPyCheckForApp()) SWIG_fail;
24600 PyThreadState* __tstate = wxPyBeginAllowThreads();
24601 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24602
24603 wxPyEndAllowThreads(__tstate);
24604 if (PyErr_Occurred()) SWIG_fail;
24605 }
24606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24607 {
24608 if (temp6)
24609 delete arg6;
24610 }
24611 return resultobj;
24612 fail:
24613 {
24614 if (temp6)
24615 delete arg6;
24616 }
24617 return NULL;
24618 }
24619
24620
24621 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24622 PyObject *resultobj;
24623 wxWindow *result;
24624 char *kwnames[] = {
24625 NULL
24626 };
24627
24628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24629 {
24630 if (!wxPyCheckForApp()) SWIG_fail;
24631 PyThreadState* __tstate = wxPyBeginAllowThreads();
24632 result = (wxWindow *)new wxWindow();
24633
24634 wxPyEndAllowThreads(__tstate);
24635 if (PyErr_Occurred()) SWIG_fail;
24636 }
24637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24638 return resultobj;
24639 fail:
24640 return NULL;
24641 }
24642
24643
24644 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24645 PyObject *resultobj;
24646 wxWindow *arg1 = (wxWindow *) 0 ;
24647 wxWindow *arg2 = (wxWindow *) 0 ;
24648 int arg3 = (int) (int)-1 ;
24649 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24650 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24651 wxSize const &arg5_defvalue = wxDefaultSize ;
24652 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24653 long arg6 = (long) 0 ;
24654 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24655 wxString *arg7 = (wxString *) &arg7_defvalue ;
24656 bool result;
24657 wxPoint temp4 ;
24658 wxSize temp5 ;
24659 bool temp7 = false ;
24660 PyObject * obj0 = 0 ;
24661 PyObject * obj1 = 0 ;
24662 PyObject * obj2 = 0 ;
24663 PyObject * obj3 = 0 ;
24664 PyObject * obj4 = 0 ;
24665 PyObject * obj5 = 0 ;
24666 PyObject * obj6 = 0 ;
24667 char *kwnames[] = {
24668 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24669 };
24670
24671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24673 if (SWIG_arg_fail(1)) SWIG_fail;
24674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24675 if (SWIG_arg_fail(2)) SWIG_fail;
24676 if (obj2) {
24677 {
24678 arg3 = (int const)(SWIG_As_int(obj2));
24679 if (SWIG_arg_fail(3)) SWIG_fail;
24680 }
24681 }
24682 if (obj3) {
24683 {
24684 arg4 = &temp4;
24685 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24686 }
24687 }
24688 if (obj4) {
24689 {
24690 arg5 = &temp5;
24691 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24692 }
24693 }
24694 if (obj5) {
24695 {
24696 arg6 = (long)(SWIG_As_long(obj5));
24697 if (SWIG_arg_fail(6)) SWIG_fail;
24698 }
24699 }
24700 if (obj6) {
24701 {
24702 arg7 = wxString_in_helper(obj6);
24703 if (arg7 == NULL) SWIG_fail;
24704 temp7 = true;
24705 }
24706 }
24707 {
24708 PyThreadState* __tstate = wxPyBeginAllowThreads();
24709 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24710
24711 wxPyEndAllowThreads(__tstate);
24712 if (PyErr_Occurred()) SWIG_fail;
24713 }
24714 {
24715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24716 }
24717 {
24718 if (temp7)
24719 delete arg7;
24720 }
24721 return resultobj;
24722 fail:
24723 {
24724 if (temp7)
24725 delete arg7;
24726 }
24727 return NULL;
24728 }
24729
24730
24731 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24732 PyObject *resultobj;
24733 wxWindow *arg1 = (wxWindow *) 0 ;
24734 bool arg2 = (bool) false ;
24735 bool result;
24736 PyObject * obj0 = 0 ;
24737 PyObject * obj1 = 0 ;
24738 char *kwnames[] = {
24739 (char *) "self",(char *) "force", NULL
24740 };
24741
24742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24744 if (SWIG_arg_fail(1)) SWIG_fail;
24745 if (obj1) {
24746 {
24747 arg2 = (bool)(SWIG_As_bool(obj1));
24748 if (SWIG_arg_fail(2)) SWIG_fail;
24749 }
24750 }
24751 {
24752 PyThreadState* __tstate = wxPyBeginAllowThreads();
24753 result = (bool)(arg1)->Close(arg2);
24754
24755 wxPyEndAllowThreads(__tstate);
24756 if (PyErr_Occurred()) SWIG_fail;
24757 }
24758 {
24759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24760 }
24761 return resultobj;
24762 fail:
24763 return NULL;
24764 }
24765
24766
24767 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24768 PyObject *resultobj;
24769 wxWindow *arg1 = (wxWindow *) 0 ;
24770 bool result;
24771 PyObject * obj0 = 0 ;
24772 char *kwnames[] = {
24773 (char *) "self", NULL
24774 };
24775
24776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24778 if (SWIG_arg_fail(1)) SWIG_fail;
24779 {
24780 PyThreadState* __tstate = wxPyBeginAllowThreads();
24781 result = (bool)(arg1)->Destroy();
24782
24783 wxPyEndAllowThreads(__tstate);
24784 if (PyErr_Occurred()) SWIG_fail;
24785 }
24786 {
24787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24788 }
24789 return resultobj;
24790 fail:
24791 return NULL;
24792 }
24793
24794
24795 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24796 PyObject *resultobj;
24797 wxWindow *arg1 = (wxWindow *) 0 ;
24798 bool result;
24799 PyObject * obj0 = 0 ;
24800 char *kwnames[] = {
24801 (char *) "self", NULL
24802 };
24803
24804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24806 if (SWIG_arg_fail(1)) SWIG_fail;
24807 {
24808 PyThreadState* __tstate = wxPyBeginAllowThreads();
24809 result = (bool)(arg1)->DestroyChildren();
24810
24811 wxPyEndAllowThreads(__tstate);
24812 if (PyErr_Occurred()) SWIG_fail;
24813 }
24814 {
24815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24816 }
24817 return resultobj;
24818 fail:
24819 return NULL;
24820 }
24821
24822
24823 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24824 PyObject *resultobj;
24825 wxWindow *arg1 = (wxWindow *) 0 ;
24826 bool result;
24827 PyObject * obj0 = 0 ;
24828 char *kwnames[] = {
24829 (char *) "self", NULL
24830 };
24831
24832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24834 if (SWIG_arg_fail(1)) SWIG_fail;
24835 {
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24838
24839 wxPyEndAllowThreads(__tstate);
24840 if (PyErr_Occurred()) SWIG_fail;
24841 }
24842 {
24843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24844 }
24845 return resultobj;
24846 fail:
24847 return NULL;
24848 }
24849
24850
24851 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24852 PyObject *resultobj;
24853 wxWindow *arg1 = (wxWindow *) 0 ;
24854 wxString *arg2 = 0 ;
24855 bool temp2 = false ;
24856 PyObject * obj0 = 0 ;
24857 PyObject * obj1 = 0 ;
24858 char *kwnames[] = {
24859 (char *) "self",(char *) "title", NULL
24860 };
24861
24862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24864 if (SWIG_arg_fail(1)) SWIG_fail;
24865 {
24866 arg2 = wxString_in_helper(obj1);
24867 if (arg2 == NULL) SWIG_fail;
24868 temp2 = true;
24869 }
24870 {
24871 PyThreadState* __tstate = wxPyBeginAllowThreads();
24872 (arg1)->SetTitle((wxString const &)*arg2);
24873
24874 wxPyEndAllowThreads(__tstate);
24875 if (PyErr_Occurred()) SWIG_fail;
24876 }
24877 Py_INCREF(Py_None); resultobj = Py_None;
24878 {
24879 if (temp2)
24880 delete arg2;
24881 }
24882 return resultobj;
24883 fail:
24884 {
24885 if (temp2)
24886 delete arg2;
24887 }
24888 return NULL;
24889 }
24890
24891
24892 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24893 PyObject *resultobj;
24894 wxWindow *arg1 = (wxWindow *) 0 ;
24895 wxString result;
24896 PyObject * obj0 = 0 ;
24897 char *kwnames[] = {
24898 (char *) "self", NULL
24899 };
24900
24901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24903 if (SWIG_arg_fail(1)) SWIG_fail;
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = ((wxWindow const *)arg1)->GetTitle();
24907
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 {
24912 #if wxUSE_UNICODE
24913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24914 #else
24915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24916 #endif
24917 }
24918 return resultobj;
24919 fail:
24920 return NULL;
24921 }
24922
24923
24924 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24925 PyObject *resultobj;
24926 wxWindow *arg1 = (wxWindow *) 0 ;
24927 wxString *arg2 = 0 ;
24928 bool temp2 = false ;
24929 PyObject * obj0 = 0 ;
24930 PyObject * obj1 = 0 ;
24931 char *kwnames[] = {
24932 (char *) "self",(char *) "label", NULL
24933 };
24934
24935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24937 if (SWIG_arg_fail(1)) SWIG_fail;
24938 {
24939 arg2 = wxString_in_helper(obj1);
24940 if (arg2 == NULL) SWIG_fail;
24941 temp2 = true;
24942 }
24943 {
24944 PyThreadState* __tstate = wxPyBeginAllowThreads();
24945 (arg1)->SetLabel((wxString const &)*arg2);
24946
24947 wxPyEndAllowThreads(__tstate);
24948 if (PyErr_Occurred()) SWIG_fail;
24949 }
24950 Py_INCREF(Py_None); resultobj = Py_None;
24951 {
24952 if (temp2)
24953 delete arg2;
24954 }
24955 return resultobj;
24956 fail:
24957 {
24958 if (temp2)
24959 delete arg2;
24960 }
24961 return NULL;
24962 }
24963
24964
24965 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24966 PyObject *resultobj;
24967 wxWindow *arg1 = (wxWindow *) 0 ;
24968 wxString result;
24969 PyObject * obj0 = 0 ;
24970 char *kwnames[] = {
24971 (char *) "self", NULL
24972 };
24973
24974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24976 if (SWIG_arg_fail(1)) SWIG_fail;
24977 {
24978 PyThreadState* __tstate = wxPyBeginAllowThreads();
24979 result = ((wxWindow const *)arg1)->GetLabel();
24980
24981 wxPyEndAllowThreads(__tstate);
24982 if (PyErr_Occurred()) SWIG_fail;
24983 }
24984 {
24985 #if wxUSE_UNICODE
24986 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24987 #else
24988 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24989 #endif
24990 }
24991 return resultobj;
24992 fail:
24993 return NULL;
24994 }
24995
24996
24997 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24998 PyObject *resultobj;
24999 wxWindow *arg1 = (wxWindow *) 0 ;
25000 wxString *arg2 = 0 ;
25001 bool temp2 = false ;
25002 PyObject * obj0 = 0 ;
25003 PyObject * obj1 = 0 ;
25004 char *kwnames[] = {
25005 (char *) "self",(char *) "name", NULL
25006 };
25007
25008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25010 if (SWIG_arg_fail(1)) SWIG_fail;
25011 {
25012 arg2 = wxString_in_helper(obj1);
25013 if (arg2 == NULL) SWIG_fail;
25014 temp2 = true;
25015 }
25016 {
25017 PyThreadState* __tstate = wxPyBeginAllowThreads();
25018 (arg1)->SetName((wxString const &)*arg2);
25019
25020 wxPyEndAllowThreads(__tstate);
25021 if (PyErr_Occurred()) SWIG_fail;
25022 }
25023 Py_INCREF(Py_None); resultobj = Py_None;
25024 {
25025 if (temp2)
25026 delete arg2;
25027 }
25028 return resultobj;
25029 fail:
25030 {
25031 if (temp2)
25032 delete arg2;
25033 }
25034 return NULL;
25035 }
25036
25037
25038 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25039 PyObject *resultobj;
25040 wxWindow *arg1 = (wxWindow *) 0 ;
25041 wxString result;
25042 PyObject * obj0 = 0 ;
25043 char *kwnames[] = {
25044 (char *) "self", NULL
25045 };
25046
25047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25049 if (SWIG_arg_fail(1)) SWIG_fail;
25050 {
25051 PyThreadState* __tstate = wxPyBeginAllowThreads();
25052 result = ((wxWindow const *)arg1)->GetName();
25053
25054 wxPyEndAllowThreads(__tstate);
25055 if (PyErr_Occurred()) SWIG_fail;
25056 }
25057 {
25058 #if wxUSE_UNICODE
25059 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25060 #else
25061 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25062 #endif
25063 }
25064 return resultobj;
25065 fail:
25066 return NULL;
25067 }
25068
25069
25070 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25071 PyObject *resultobj;
25072 wxWindow *arg1 = (wxWindow *) 0 ;
25073 wxWindowVariant arg2 ;
25074 PyObject * obj0 = 0 ;
25075 PyObject * obj1 = 0 ;
25076 char *kwnames[] = {
25077 (char *) "self",(char *) "variant", NULL
25078 };
25079
25080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25082 if (SWIG_arg_fail(1)) SWIG_fail;
25083 {
25084 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25085 if (SWIG_arg_fail(2)) SWIG_fail;
25086 }
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25090
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 Py_INCREF(Py_None); resultobj = Py_None;
25095 return resultobj;
25096 fail:
25097 return NULL;
25098 }
25099
25100
25101 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25102 PyObject *resultobj;
25103 wxWindow *arg1 = (wxWindow *) 0 ;
25104 wxWindowVariant result;
25105 PyObject * obj0 = 0 ;
25106 char *kwnames[] = {
25107 (char *) "self", NULL
25108 };
25109
25110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25112 if (SWIG_arg_fail(1)) SWIG_fail;
25113 {
25114 PyThreadState* __tstate = wxPyBeginAllowThreads();
25115 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25116
25117 wxPyEndAllowThreads(__tstate);
25118 if (PyErr_Occurred()) SWIG_fail;
25119 }
25120 resultobj = SWIG_From_int((result));
25121 return resultobj;
25122 fail:
25123 return NULL;
25124 }
25125
25126
25127 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25128 PyObject *resultobj;
25129 wxWindow *arg1 = (wxWindow *) 0 ;
25130 int arg2 ;
25131 PyObject * obj0 = 0 ;
25132 PyObject * obj1 = 0 ;
25133 char *kwnames[] = {
25134 (char *) "self",(char *) "winid", NULL
25135 };
25136
25137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25139 if (SWIG_arg_fail(1)) SWIG_fail;
25140 {
25141 arg2 = (int)(SWIG_As_int(obj1));
25142 if (SWIG_arg_fail(2)) SWIG_fail;
25143 }
25144 {
25145 PyThreadState* __tstate = wxPyBeginAllowThreads();
25146 (arg1)->SetId(arg2);
25147
25148 wxPyEndAllowThreads(__tstate);
25149 if (PyErr_Occurred()) SWIG_fail;
25150 }
25151 Py_INCREF(Py_None); resultobj = Py_None;
25152 return resultobj;
25153 fail:
25154 return NULL;
25155 }
25156
25157
25158 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25159 PyObject *resultobj;
25160 wxWindow *arg1 = (wxWindow *) 0 ;
25161 int result;
25162 PyObject * obj0 = 0 ;
25163 char *kwnames[] = {
25164 (char *) "self", NULL
25165 };
25166
25167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25169 if (SWIG_arg_fail(1)) SWIG_fail;
25170 {
25171 PyThreadState* __tstate = wxPyBeginAllowThreads();
25172 result = (int)((wxWindow const *)arg1)->GetId();
25173
25174 wxPyEndAllowThreads(__tstate);
25175 if (PyErr_Occurred()) SWIG_fail;
25176 }
25177 {
25178 resultobj = SWIG_From_int((int)(result));
25179 }
25180 return resultobj;
25181 fail:
25182 return NULL;
25183 }
25184
25185
25186 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25187 PyObject *resultobj;
25188 int result;
25189 char *kwnames[] = {
25190 NULL
25191 };
25192
25193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25194 {
25195 PyThreadState* __tstate = wxPyBeginAllowThreads();
25196 result = (int)wxWindow::NewControlId();
25197
25198 wxPyEndAllowThreads(__tstate);
25199 if (PyErr_Occurred()) SWIG_fail;
25200 }
25201 {
25202 resultobj = SWIG_From_int((int)(result));
25203 }
25204 return resultobj;
25205 fail:
25206 return NULL;
25207 }
25208
25209
25210 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25211 PyObject *resultobj;
25212 int arg1 ;
25213 int result;
25214 PyObject * obj0 = 0 ;
25215 char *kwnames[] = {
25216 (char *) "winid", NULL
25217 };
25218
25219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25220 {
25221 arg1 = (int)(SWIG_As_int(obj0));
25222 if (SWIG_arg_fail(1)) SWIG_fail;
25223 }
25224 {
25225 PyThreadState* __tstate = wxPyBeginAllowThreads();
25226 result = (int)wxWindow::NextControlId(arg1);
25227
25228 wxPyEndAllowThreads(__tstate);
25229 if (PyErr_Occurred()) SWIG_fail;
25230 }
25231 {
25232 resultobj = SWIG_From_int((int)(result));
25233 }
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25241 PyObject *resultobj;
25242 int arg1 ;
25243 int result;
25244 PyObject * obj0 = 0 ;
25245 char *kwnames[] = {
25246 (char *) "winid", NULL
25247 };
25248
25249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25250 {
25251 arg1 = (int)(SWIG_As_int(obj0));
25252 if (SWIG_arg_fail(1)) SWIG_fail;
25253 }
25254 {
25255 PyThreadState* __tstate = wxPyBeginAllowThreads();
25256 result = (int)wxWindow::PrevControlId(arg1);
25257
25258 wxPyEndAllowThreads(__tstate);
25259 if (PyErr_Occurred()) SWIG_fail;
25260 }
25261 {
25262 resultobj = SWIG_From_int((int)(result));
25263 }
25264 return resultobj;
25265 fail:
25266 return NULL;
25267 }
25268
25269
25270 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25271 PyObject *resultobj;
25272 wxWindow *arg1 = (wxWindow *) 0 ;
25273 wxSize *arg2 = 0 ;
25274 wxSize temp2 ;
25275 PyObject * obj0 = 0 ;
25276 PyObject * obj1 = 0 ;
25277 char *kwnames[] = {
25278 (char *) "self",(char *) "size", NULL
25279 };
25280
25281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25283 if (SWIG_arg_fail(1)) SWIG_fail;
25284 {
25285 arg2 = &temp2;
25286 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25287 }
25288 {
25289 PyThreadState* __tstate = wxPyBeginAllowThreads();
25290 (arg1)->SetSize((wxSize const &)*arg2);
25291
25292 wxPyEndAllowThreads(__tstate);
25293 if (PyErr_Occurred()) SWIG_fail;
25294 }
25295 Py_INCREF(Py_None); resultobj = Py_None;
25296 return resultobj;
25297 fail:
25298 return NULL;
25299 }
25300
25301
25302 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25303 PyObject *resultobj;
25304 wxWindow *arg1 = (wxWindow *) 0 ;
25305 int arg2 ;
25306 int arg3 ;
25307 int arg4 ;
25308 int arg5 ;
25309 int arg6 = (int) wxSIZE_AUTO ;
25310 PyObject * obj0 = 0 ;
25311 PyObject * obj1 = 0 ;
25312 PyObject * obj2 = 0 ;
25313 PyObject * obj3 = 0 ;
25314 PyObject * obj4 = 0 ;
25315 PyObject * obj5 = 0 ;
25316 char *kwnames[] = {
25317 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25318 };
25319
25320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25322 if (SWIG_arg_fail(1)) SWIG_fail;
25323 {
25324 arg2 = (int)(SWIG_As_int(obj1));
25325 if (SWIG_arg_fail(2)) SWIG_fail;
25326 }
25327 {
25328 arg3 = (int)(SWIG_As_int(obj2));
25329 if (SWIG_arg_fail(3)) SWIG_fail;
25330 }
25331 {
25332 arg4 = (int)(SWIG_As_int(obj3));
25333 if (SWIG_arg_fail(4)) SWIG_fail;
25334 }
25335 {
25336 arg5 = (int)(SWIG_As_int(obj4));
25337 if (SWIG_arg_fail(5)) SWIG_fail;
25338 }
25339 if (obj5) {
25340 {
25341 arg6 = (int)(SWIG_As_int(obj5));
25342 if (SWIG_arg_fail(6)) SWIG_fail;
25343 }
25344 }
25345 {
25346 PyThreadState* __tstate = wxPyBeginAllowThreads();
25347 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25348
25349 wxPyEndAllowThreads(__tstate);
25350 if (PyErr_Occurred()) SWIG_fail;
25351 }
25352 Py_INCREF(Py_None); resultobj = Py_None;
25353 return resultobj;
25354 fail:
25355 return NULL;
25356 }
25357
25358
25359 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25360 PyObject *resultobj;
25361 wxWindow *arg1 = (wxWindow *) 0 ;
25362 wxRect *arg2 = 0 ;
25363 int arg3 = (int) wxSIZE_AUTO ;
25364 wxRect temp2 ;
25365 PyObject * obj0 = 0 ;
25366 PyObject * obj1 = 0 ;
25367 PyObject * obj2 = 0 ;
25368 char *kwnames[] = {
25369 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25370 };
25371
25372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25374 if (SWIG_arg_fail(1)) SWIG_fail;
25375 {
25376 arg2 = &temp2;
25377 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25378 }
25379 if (obj2) {
25380 {
25381 arg3 = (int)(SWIG_As_int(obj2));
25382 if (SWIG_arg_fail(3)) SWIG_fail;
25383 }
25384 }
25385 {
25386 PyThreadState* __tstate = wxPyBeginAllowThreads();
25387 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25388
25389 wxPyEndAllowThreads(__tstate);
25390 if (PyErr_Occurred()) SWIG_fail;
25391 }
25392 Py_INCREF(Py_None); resultobj = Py_None;
25393 return resultobj;
25394 fail:
25395 return NULL;
25396 }
25397
25398
25399 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25400 PyObject *resultobj;
25401 wxWindow *arg1 = (wxWindow *) 0 ;
25402 int arg2 ;
25403 int arg3 ;
25404 PyObject * obj0 = 0 ;
25405 PyObject * obj1 = 0 ;
25406 PyObject * obj2 = 0 ;
25407 char *kwnames[] = {
25408 (char *) "self",(char *) "width",(char *) "height", NULL
25409 };
25410
25411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25413 if (SWIG_arg_fail(1)) SWIG_fail;
25414 {
25415 arg2 = (int)(SWIG_As_int(obj1));
25416 if (SWIG_arg_fail(2)) SWIG_fail;
25417 }
25418 {
25419 arg3 = (int)(SWIG_As_int(obj2));
25420 if (SWIG_arg_fail(3)) SWIG_fail;
25421 }
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 (arg1)->SetSize(arg2,arg3);
25425
25426 wxPyEndAllowThreads(__tstate);
25427 if (PyErr_Occurred()) SWIG_fail;
25428 }
25429 Py_INCREF(Py_None); resultobj = Py_None;
25430 return resultobj;
25431 fail:
25432 return NULL;
25433 }
25434
25435
25436 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25437 PyObject *resultobj;
25438 wxWindow *arg1 = (wxWindow *) 0 ;
25439 wxPoint *arg2 = 0 ;
25440 int arg3 = (int) wxSIZE_USE_EXISTING ;
25441 wxPoint temp2 ;
25442 PyObject * obj0 = 0 ;
25443 PyObject * obj1 = 0 ;
25444 PyObject * obj2 = 0 ;
25445 char *kwnames[] = {
25446 (char *) "self",(char *) "pt",(char *) "flags", NULL
25447 };
25448
25449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25451 if (SWIG_arg_fail(1)) SWIG_fail;
25452 {
25453 arg2 = &temp2;
25454 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25455 }
25456 if (obj2) {
25457 {
25458 arg3 = (int)(SWIG_As_int(obj2));
25459 if (SWIG_arg_fail(3)) SWIG_fail;
25460 }
25461 }
25462 {
25463 PyThreadState* __tstate = wxPyBeginAllowThreads();
25464 (arg1)->Move((wxPoint const &)*arg2,arg3);
25465
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 Py_INCREF(Py_None); resultobj = Py_None;
25470 return resultobj;
25471 fail:
25472 return NULL;
25473 }
25474
25475
25476 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25477 PyObject *resultobj;
25478 wxWindow *arg1 = (wxWindow *) 0 ;
25479 int arg2 ;
25480 int arg3 ;
25481 int arg4 = (int) wxSIZE_USE_EXISTING ;
25482 PyObject * obj0 = 0 ;
25483 PyObject * obj1 = 0 ;
25484 PyObject * obj2 = 0 ;
25485 PyObject * obj3 = 0 ;
25486 char *kwnames[] = {
25487 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25488 };
25489
25490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25492 if (SWIG_arg_fail(1)) SWIG_fail;
25493 {
25494 arg2 = (int)(SWIG_As_int(obj1));
25495 if (SWIG_arg_fail(2)) SWIG_fail;
25496 }
25497 {
25498 arg3 = (int)(SWIG_As_int(obj2));
25499 if (SWIG_arg_fail(3)) SWIG_fail;
25500 }
25501 if (obj3) {
25502 {
25503 arg4 = (int)(SWIG_As_int(obj3));
25504 if (SWIG_arg_fail(4)) SWIG_fail;
25505 }
25506 }
25507 {
25508 PyThreadState* __tstate = wxPyBeginAllowThreads();
25509 (arg1)->Move(arg2,arg3,arg4);
25510
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 Py_INCREF(Py_None); resultobj = Py_None;
25515 return resultobj;
25516 fail:
25517 return NULL;
25518 }
25519
25520
25521 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25522 PyObject *resultobj;
25523 wxWindow *arg1 = (wxWindow *) 0 ;
25524 wxSize const &arg2_defvalue = wxDefaultSize ;
25525 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25526 wxSize temp2 ;
25527 PyObject * obj0 = 0 ;
25528 PyObject * obj1 = 0 ;
25529 char *kwnames[] = {
25530 (char *) "self",(char *) "size", NULL
25531 };
25532
25533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25535 if (SWIG_arg_fail(1)) SWIG_fail;
25536 if (obj1) {
25537 {
25538 arg2 = &temp2;
25539 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25540 }
25541 }
25542 {
25543 PyThreadState* __tstate = wxPyBeginAllowThreads();
25544 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25545
25546 wxPyEndAllowThreads(__tstate);
25547 if (PyErr_Occurred()) SWIG_fail;
25548 }
25549 Py_INCREF(Py_None); resultobj = Py_None;
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25557 PyObject *resultobj;
25558 wxWindow *arg1 = (wxWindow *) 0 ;
25559 PyObject * obj0 = 0 ;
25560 char *kwnames[] = {
25561 (char *) "self", NULL
25562 };
25563
25564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25566 if (SWIG_arg_fail(1)) SWIG_fail;
25567 {
25568 PyThreadState* __tstate = wxPyBeginAllowThreads();
25569 (arg1)->Raise();
25570
25571 wxPyEndAllowThreads(__tstate);
25572 if (PyErr_Occurred()) SWIG_fail;
25573 }
25574 Py_INCREF(Py_None); resultobj = Py_None;
25575 return resultobj;
25576 fail:
25577 return NULL;
25578 }
25579
25580
25581 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25582 PyObject *resultobj;
25583 wxWindow *arg1 = (wxWindow *) 0 ;
25584 PyObject * obj0 = 0 ;
25585 char *kwnames[] = {
25586 (char *) "self", NULL
25587 };
25588
25589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25591 if (SWIG_arg_fail(1)) SWIG_fail;
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 (arg1)->Lower();
25595
25596 wxPyEndAllowThreads(__tstate);
25597 if (PyErr_Occurred()) SWIG_fail;
25598 }
25599 Py_INCREF(Py_None); resultobj = Py_None;
25600 return resultobj;
25601 fail:
25602 return NULL;
25603 }
25604
25605
25606 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25607 PyObject *resultobj;
25608 wxWindow *arg1 = (wxWindow *) 0 ;
25609 wxSize *arg2 = 0 ;
25610 wxSize temp2 ;
25611 PyObject * obj0 = 0 ;
25612 PyObject * obj1 = 0 ;
25613 char *kwnames[] = {
25614 (char *) "self",(char *) "size", NULL
25615 };
25616
25617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25619 if (SWIG_arg_fail(1)) SWIG_fail;
25620 {
25621 arg2 = &temp2;
25622 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25623 }
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 (arg1)->SetClientSize((wxSize const &)*arg2);
25627
25628 wxPyEndAllowThreads(__tstate);
25629 if (PyErr_Occurred()) SWIG_fail;
25630 }
25631 Py_INCREF(Py_None); resultobj = Py_None;
25632 return resultobj;
25633 fail:
25634 return NULL;
25635 }
25636
25637
25638 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25639 PyObject *resultobj;
25640 wxWindow *arg1 = (wxWindow *) 0 ;
25641 int arg2 ;
25642 int arg3 ;
25643 PyObject * obj0 = 0 ;
25644 PyObject * obj1 = 0 ;
25645 PyObject * obj2 = 0 ;
25646 char *kwnames[] = {
25647 (char *) "self",(char *) "width",(char *) "height", NULL
25648 };
25649
25650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25652 if (SWIG_arg_fail(1)) SWIG_fail;
25653 {
25654 arg2 = (int)(SWIG_As_int(obj1));
25655 if (SWIG_arg_fail(2)) SWIG_fail;
25656 }
25657 {
25658 arg3 = (int)(SWIG_As_int(obj2));
25659 if (SWIG_arg_fail(3)) SWIG_fail;
25660 }
25661 {
25662 PyThreadState* __tstate = wxPyBeginAllowThreads();
25663 (arg1)->SetClientSize(arg2,arg3);
25664
25665 wxPyEndAllowThreads(__tstate);
25666 if (PyErr_Occurred()) SWIG_fail;
25667 }
25668 Py_INCREF(Py_None); resultobj = Py_None;
25669 return resultobj;
25670 fail:
25671 return NULL;
25672 }
25673
25674
25675 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25676 PyObject *resultobj;
25677 wxWindow *arg1 = (wxWindow *) 0 ;
25678 wxRect *arg2 = 0 ;
25679 wxRect temp2 ;
25680 PyObject * obj0 = 0 ;
25681 PyObject * obj1 = 0 ;
25682 char *kwnames[] = {
25683 (char *) "self",(char *) "rect", NULL
25684 };
25685
25686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25688 if (SWIG_arg_fail(1)) SWIG_fail;
25689 {
25690 arg2 = &temp2;
25691 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25692 }
25693 {
25694 PyThreadState* __tstate = wxPyBeginAllowThreads();
25695 (arg1)->SetClientSize((wxRect const &)*arg2);
25696
25697 wxPyEndAllowThreads(__tstate);
25698 if (PyErr_Occurred()) SWIG_fail;
25699 }
25700 Py_INCREF(Py_None); resultobj = Py_None;
25701 return resultobj;
25702 fail:
25703 return NULL;
25704 }
25705
25706
25707 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25708 PyObject *resultobj;
25709 wxWindow *arg1 = (wxWindow *) 0 ;
25710 wxPoint result;
25711 PyObject * obj0 = 0 ;
25712 char *kwnames[] = {
25713 (char *) "self", NULL
25714 };
25715
25716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25718 if (SWIG_arg_fail(1)) SWIG_fail;
25719 {
25720 PyThreadState* __tstate = wxPyBeginAllowThreads();
25721 result = (arg1)->GetPosition();
25722
25723 wxPyEndAllowThreads(__tstate);
25724 if (PyErr_Occurred()) SWIG_fail;
25725 }
25726 {
25727 wxPoint * resultptr;
25728 resultptr = new wxPoint((wxPoint &)(result));
25729 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25730 }
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25738 PyObject *resultobj;
25739 wxWindow *arg1 = (wxWindow *) 0 ;
25740 int *arg2 = (int *) 0 ;
25741 int *arg3 = (int *) 0 ;
25742 int temp2 ;
25743 int res2 = 0 ;
25744 int temp3 ;
25745 int res3 = 0 ;
25746 PyObject * obj0 = 0 ;
25747 char *kwnames[] = {
25748 (char *) "self", NULL
25749 };
25750
25751 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25752 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25755 if (SWIG_arg_fail(1)) SWIG_fail;
25756 {
25757 PyThreadState* __tstate = wxPyBeginAllowThreads();
25758 (arg1)->GetPosition(arg2,arg3);
25759
25760 wxPyEndAllowThreads(__tstate);
25761 if (PyErr_Occurred()) SWIG_fail;
25762 }
25763 Py_INCREF(Py_None); resultobj = Py_None;
25764 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25765 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25766 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25767 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25768 return resultobj;
25769 fail:
25770 return NULL;
25771 }
25772
25773
25774 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25775 PyObject *resultobj;
25776 wxWindow *arg1 = (wxWindow *) 0 ;
25777 wxSize result;
25778 PyObject * obj0 = 0 ;
25779 char *kwnames[] = {
25780 (char *) "self", NULL
25781 };
25782
25783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25785 if (SWIG_arg_fail(1)) SWIG_fail;
25786 {
25787 PyThreadState* __tstate = wxPyBeginAllowThreads();
25788 result = ((wxWindow const *)arg1)->GetSize();
25789
25790 wxPyEndAllowThreads(__tstate);
25791 if (PyErr_Occurred()) SWIG_fail;
25792 }
25793 {
25794 wxSize * resultptr;
25795 resultptr = new wxSize((wxSize &)(result));
25796 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25797 }
25798 return resultobj;
25799 fail:
25800 return NULL;
25801 }
25802
25803
25804 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25805 PyObject *resultobj;
25806 wxWindow *arg1 = (wxWindow *) 0 ;
25807 int *arg2 = (int *) 0 ;
25808 int *arg3 = (int *) 0 ;
25809 int temp2 ;
25810 int res2 = 0 ;
25811 int temp3 ;
25812 int res3 = 0 ;
25813 PyObject * obj0 = 0 ;
25814 char *kwnames[] = {
25815 (char *) "self", NULL
25816 };
25817
25818 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25819 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25822 if (SWIG_arg_fail(1)) SWIG_fail;
25823 {
25824 PyThreadState* __tstate = wxPyBeginAllowThreads();
25825 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25826
25827 wxPyEndAllowThreads(__tstate);
25828 if (PyErr_Occurred()) SWIG_fail;
25829 }
25830 Py_INCREF(Py_None); resultobj = Py_None;
25831 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25832 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25833 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25834 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25835 return resultobj;
25836 fail:
25837 return NULL;
25838 }
25839
25840
25841 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25842 PyObject *resultobj;
25843 wxWindow *arg1 = (wxWindow *) 0 ;
25844 wxRect result;
25845 PyObject * obj0 = 0 ;
25846 char *kwnames[] = {
25847 (char *) "self", NULL
25848 };
25849
25850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25852 if (SWIG_arg_fail(1)) SWIG_fail;
25853 {
25854 PyThreadState* __tstate = wxPyBeginAllowThreads();
25855 result = ((wxWindow const *)arg1)->GetRect();
25856
25857 wxPyEndAllowThreads(__tstate);
25858 if (PyErr_Occurred()) SWIG_fail;
25859 }
25860 {
25861 wxRect * resultptr;
25862 resultptr = new wxRect((wxRect &)(result));
25863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25864 }
25865 return resultobj;
25866 fail:
25867 return NULL;
25868 }
25869
25870
25871 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25872 PyObject *resultobj;
25873 wxWindow *arg1 = (wxWindow *) 0 ;
25874 wxSize result;
25875 PyObject * obj0 = 0 ;
25876 char *kwnames[] = {
25877 (char *) "self", NULL
25878 };
25879
25880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25882 if (SWIG_arg_fail(1)) SWIG_fail;
25883 {
25884 PyThreadState* __tstate = wxPyBeginAllowThreads();
25885 result = ((wxWindow const *)arg1)->GetClientSize();
25886
25887 wxPyEndAllowThreads(__tstate);
25888 if (PyErr_Occurred()) SWIG_fail;
25889 }
25890 {
25891 wxSize * resultptr;
25892 resultptr = new wxSize((wxSize &)(result));
25893 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25894 }
25895 return resultobj;
25896 fail:
25897 return NULL;
25898 }
25899
25900
25901 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25902 PyObject *resultobj;
25903 wxWindow *arg1 = (wxWindow *) 0 ;
25904 int *arg2 = (int *) 0 ;
25905 int *arg3 = (int *) 0 ;
25906 int temp2 ;
25907 int res2 = 0 ;
25908 int temp3 ;
25909 int res3 = 0 ;
25910 PyObject * obj0 = 0 ;
25911 char *kwnames[] = {
25912 (char *) "self", NULL
25913 };
25914
25915 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25916 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25919 if (SWIG_arg_fail(1)) SWIG_fail;
25920 {
25921 PyThreadState* __tstate = wxPyBeginAllowThreads();
25922 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25923
25924 wxPyEndAllowThreads(__tstate);
25925 if (PyErr_Occurred()) SWIG_fail;
25926 }
25927 Py_INCREF(Py_None); resultobj = Py_None;
25928 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25929 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25930 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25931 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25932 return resultobj;
25933 fail:
25934 return NULL;
25935 }
25936
25937
25938 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25939 PyObject *resultobj;
25940 wxWindow *arg1 = (wxWindow *) 0 ;
25941 wxPoint result;
25942 PyObject * obj0 = 0 ;
25943 char *kwnames[] = {
25944 (char *) "self", NULL
25945 };
25946
25947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25949 if (SWIG_arg_fail(1)) SWIG_fail;
25950 {
25951 PyThreadState* __tstate = wxPyBeginAllowThreads();
25952 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25953
25954 wxPyEndAllowThreads(__tstate);
25955 if (PyErr_Occurred()) SWIG_fail;
25956 }
25957 {
25958 wxPoint * resultptr;
25959 resultptr = new wxPoint((wxPoint &)(result));
25960 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25961 }
25962 return resultobj;
25963 fail:
25964 return NULL;
25965 }
25966
25967
25968 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25969 PyObject *resultobj;
25970 wxWindow *arg1 = (wxWindow *) 0 ;
25971 wxRect result;
25972 PyObject * obj0 = 0 ;
25973 char *kwnames[] = {
25974 (char *) "self", NULL
25975 };
25976
25977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25979 if (SWIG_arg_fail(1)) SWIG_fail;
25980 {
25981 PyThreadState* __tstate = wxPyBeginAllowThreads();
25982 result = ((wxWindow const *)arg1)->GetClientRect();
25983
25984 wxPyEndAllowThreads(__tstate);
25985 if (PyErr_Occurred()) SWIG_fail;
25986 }
25987 {
25988 wxRect * resultptr;
25989 resultptr = new wxRect((wxRect &)(result));
25990 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25991 }
25992 return resultobj;
25993 fail:
25994 return NULL;
25995 }
25996
25997
25998 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25999 PyObject *resultobj;
26000 wxWindow *arg1 = (wxWindow *) 0 ;
26001 wxSize result;
26002 PyObject * obj0 = 0 ;
26003 char *kwnames[] = {
26004 (char *) "self", NULL
26005 };
26006
26007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26009 if (SWIG_arg_fail(1)) SWIG_fail;
26010 {
26011 PyThreadState* __tstate = wxPyBeginAllowThreads();
26012 result = ((wxWindow const *)arg1)->GetBestSize();
26013
26014 wxPyEndAllowThreads(__tstate);
26015 if (PyErr_Occurred()) SWIG_fail;
26016 }
26017 {
26018 wxSize * resultptr;
26019 resultptr = new wxSize((wxSize &)(result));
26020 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26021 }
26022 return resultobj;
26023 fail:
26024 return NULL;
26025 }
26026
26027
26028 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26029 PyObject *resultobj;
26030 wxWindow *arg1 = (wxWindow *) 0 ;
26031 int *arg2 = (int *) 0 ;
26032 int *arg3 = (int *) 0 ;
26033 int temp2 ;
26034 int res2 = 0 ;
26035 int temp3 ;
26036 int res3 = 0 ;
26037 PyObject * obj0 = 0 ;
26038 char *kwnames[] = {
26039 (char *) "self", NULL
26040 };
26041
26042 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26043 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26046 if (SWIG_arg_fail(1)) SWIG_fail;
26047 {
26048 PyThreadState* __tstate = wxPyBeginAllowThreads();
26049 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26050
26051 wxPyEndAllowThreads(__tstate);
26052 if (PyErr_Occurred()) SWIG_fail;
26053 }
26054 Py_INCREF(Py_None); resultobj = Py_None;
26055 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26056 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26057 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26058 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26059 return resultobj;
26060 fail:
26061 return NULL;
26062 }
26063
26064
26065 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26066 PyObject *resultobj;
26067 wxWindow *arg1 = (wxWindow *) 0 ;
26068 PyObject * obj0 = 0 ;
26069 char *kwnames[] = {
26070 (char *) "self", NULL
26071 };
26072
26073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26075 if (SWIG_arg_fail(1)) SWIG_fail;
26076 {
26077 PyThreadState* __tstate = wxPyBeginAllowThreads();
26078 (arg1)->InvalidateBestSize();
26079
26080 wxPyEndAllowThreads(__tstate);
26081 if (PyErr_Occurred()) SWIG_fail;
26082 }
26083 Py_INCREF(Py_None); resultobj = Py_None;
26084 return resultobj;
26085 fail:
26086 return NULL;
26087 }
26088
26089
26090 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26091 PyObject *resultobj;
26092 wxWindow *arg1 = (wxWindow *) 0 ;
26093 wxSize result;
26094 PyObject * obj0 = 0 ;
26095 char *kwnames[] = {
26096 (char *) "self", NULL
26097 };
26098
26099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26101 if (SWIG_arg_fail(1)) SWIG_fail;
26102 {
26103 PyThreadState* __tstate = wxPyBeginAllowThreads();
26104 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26105
26106 wxPyEndAllowThreads(__tstate);
26107 if (PyErr_Occurred()) SWIG_fail;
26108 }
26109 {
26110 wxSize * resultptr;
26111 resultptr = new wxSize((wxSize &)(result));
26112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26113 }
26114 return resultobj;
26115 fail:
26116 return NULL;
26117 }
26118
26119
26120 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26121 PyObject *resultobj;
26122 wxWindow *arg1 = (wxWindow *) 0 ;
26123 wxSize result;
26124 PyObject * obj0 = 0 ;
26125 char *kwnames[] = {
26126 (char *) "self", NULL
26127 };
26128
26129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26131 if (SWIG_arg_fail(1)) SWIG_fail;
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26135
26136 wxPyEndAllowThreads(__tstate);
26137 if (PyErr_Occurred()) SWIG_fail;
26138 }
26139 {
26140 wxSize * resultptr;
26141 resultptr = new wxSize((wxSize &)(result));
26142 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26143 }
26144 return resultobj;
26145 fail:
26146 return NULL;
26147 }
26148
26149
26150 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26151 PyObject *resultobj;
26152 wxWindow *arg1 = (wxWindow *) 0 ;
26153 int arg2 = (int) wxBOTH ;
26154 PyObject * obj0 = 0 ;
26155 PyObject * obj1 = 0 ;
26156 char *kwnames[] = {
26157 (char *) "self",(char *) "direction", NULL
26158 };
26159
26160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26162 if (SWIG_arg_fail(1)) SWIG_fail;
26163 if (obj1) {
26164 {
26165 arg2 = (int)(SWIG_As_int(obj1));
26166 if (SWIG_arg_fail(2)) SWIG_fail;
26167 }
26168 }
26169 {
26170 PyThreadState* __tstate = wxPyBeginAllowThreads();
26171 (arg1)->Center(arg2);
26172
26173 wxPyEndAllowThreads(__tstate);
26174 if (PyErr_Occurred()) SWIG_fail;
26175 }
26176 Py_INCREF(Py_None); resultobj = Py_None;
26177 return resultobj;
26178 fail:
26179 return NULL;
26180 }
26181
26182
26183 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26184 PyObject *resultobj;
26185 wxWindow *arg1 = (wxWindow *) 0 ;
26186 int arg2 = (int) wxBOTH ;
26187 PyObject * obj0 = 0 ;
26188 PyObject * obj1 = 0 ;
26189 char *kwnames[] = {
26190 (char *) "self",(char *) "dir", NULL
26191 };
26192
26193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26195 if (SWIG_arg_fail(1)) SWIG_fail;
26196 if (obj1) {
26197 {
26198 arg2 = (int)(SWIG_As_int(obj1));
26199 if (SWIG_arg_fail(2)) SWIG_fail;
26200 }
26201 }
26202 {
26203 PyThreadState* __tstate = wxPyBeginAllowThreads();
26204 (arg1)->CenterOnScreen(arg2);
26205
26206 wxPyEndAllowThreads(__tstate);
26207 if (PyErr_Occurred()) SWIG_fail;
26208 }
26209 Py_INCREF(Py_None); resultobj = Py_None;
26210 return resultobj;
26211 fail:
26212 return NULL;
26213 }
26214
26215
26216 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26217 PyObject *resultobj;
26218 wxWindow *arg1 = (wxWindow *) 0 ;
26219 int arg2 = (int) wxBOTH ;
26220 PyObject * obj0 = 0 ;
26221 PyObject * obj1 = 0 ;
26222 char *kwnames[] = {
26223 (char *) "self",(char *) "dir", NULL
26224 };
26225
26226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26228 if (SWIG_arg_fail(1)) SWIG_fail;
26229 if (obj1) {
26230 {
26231 arg2 = (int)(SWIG_As_int(obj1));
26232 if (SWIG_arg_fail(2)) SWIG_fail;
26233 }
26234 }
26235 {
26236 PyThreadState* __tstate = wxPyBeginAllowThreads();
26237 (arg1)->CenterOnParent(arg2);
26238
26239 wxPyEndAllowThreads(__tstate);
26240 if (PyErr_Occurred()) SWIG_fail;
26241 }
26242 Py_INCREF(Py_None); resultobj = Py_None;
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj;
26251 wxWindow *arg1 = (wxWindow *) 0 ;
26252 PyObject * obj0 = 0 ;
26253 char *kwnames[] = {
26254 (char *) "self", NULL
26255 };
26256
26257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26259 if (SWIG_arg_fail(1)) SWIG_fail;
26260 {
26261 PyThreadState* __tstate = wxPyBeginAllowThreads();
26262 (arg1)->Fit();
26263
26264 wxPyEndAllowThreads(__tstate);
26265 if (PyErr_Occurred()) SWIG_fail;
26266 }
26267 Py_INCREF(Py_None); resultobj = Py_None;
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26275 PyObject *resultobj;
26276 wxWindow *arg1 = (wxWindow *) 0 ;
26277 PyObject * obj0 = 0 ;
26278 char *kwnames[] = {
26279 (char *) "self", NULL
26280 };
26281
26282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26284 if (SWIG_arg_fail(1)) SWIG_fail;
26285 {
26286 PyThreadState* __tstate = wxPyBeginAllowThreads();
26287 (arg1)->FitInside();
26288
26289 wxPyEndAllowThreads(__tstate);
26290 if (PyErr_Occurred()) SWIG_fail;
26291 }
26292 Py_INCREF(Py_None); resultobj = Py_None;
26293 return resultobj;
26294 fail:
26295 return NULL;
26296 }
26297
26298
26299 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26300 PyObject *resultobj;
26301 wxWindow *arg1 = (wxWindow *) 0 ;
26302 int arg2 ;
26303 int arg3 ;
26304 int arg4 = (int) -1 ;
26305 int arg5 = (int) -1 ;
26306 int arg6 = (int) -1 ;
26307 int arg7 = (int) -1 ;
26308 PyObject * obj0 = 0 ;
26309 PyObject * obj1 = 0 ;
26310 PyObject * obj2 = 0 ;
26311 PyObject * obj3 = 0 ;
26312 PyObject * obj4 = 0 ;
26313 PyObject * obj5 = 0 ;
26314 PyObject * obj6 = 0 ;
26315 char *kwnames[] = {
26316 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26317 };
26318
26319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26321 if (SWIG_arg_fail(1)) SWIG_fail;
26322 {
26323 arg2 = (int)(SWIG_As_int(obj1));
26324 if (SWIG_arg_fail(2)) SWIG_fail;
26325 }
26326 {
26327 arg3 = (int)(SWIG_As_int(obj2));
26328 if (SWIG_arg_fail(3)) SWIG_fail;
26329 }
26330 if (obj3) {
26331 {
26332 arg4 = (int)(SWIG_As_int(obj3));
26333 if (SWIG_arg_fail(4)) SWIG_fail;
26334 }
26335 }
26336 if (obj4) {
26337 {
26338 arg5 = (int)(SWIG_As_int(obj4));
26339 if (SWIG_arg_fail(5)) SWIG_fail;
26340 }
26341 }
26342 if (obj5) {
26343 {
26344 arg6 = (int)(SWIG_As_int(obj5));
26345 if (SWIG_arg_fail(6)) SWIG_fail;
26346 }
26347 }
26348 if (obj6) {
26349 {
26350 arg7 = (int)(SWIG_As_int(obj6));
26351 if (SWIG_arg_fail(7)) SWIG_fail;
26352 }
26353 }
26354 {
26355 PyThreadState* __tstate = wxPyBeginAllowThreads();
26356 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26357
26358 wxPyEndAllowThreads(__tstate);
26359 if (PyErr_Occurred()) SWIG_fail;
26360 }
26361 Py_INCREF(Py_None); resultobj = Py_None;
26362 return resultobj;
26363 fail:
26364 return NULL;
26365 }
26366
26367
26368 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26369 PyObject *resultobj;
26370 wxWindow *arg1 = (wxWindow *) 0 ;
26371 wxSize *arg2 = 0 ;
26372 wxSize const &arg3_defvalue = wxDefaultSize ;
26373 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26374 wxSize const &arg4_defvalue = wxDefaultSize ;
26375 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26376 wxSize temp2 ;
26377 wxSize temp3 ;
26378 wxSize temp4 ;
26379 PyObject * obj0 = 0 ;
26380 PyObject * obj1 = 0 ;
26381 PyObject * obj2 = 0 ;
26382 PyObject * obj3 = 0 ;
26383 char *kwnames[] = {
26384 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26385 };
26386
26387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26389 if (SWIG_arg_fail(1)) SWIG_fail;
26390 {
26391 arg2 = &temp2;
26392 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26393 }
26394 if (obj2) {
26395 {
26396 arg3 = &temp3;
26397 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26398 }
26399 }
26400 if (obj3) {
26401 {
26402 arg4 = &temp4;
26403 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26404 }
26405 }
26406 {
26407 PyThreadState* __tstate = wxPyBeginAllowThreads();
26408 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26409
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 Py_INCREF(Py_None); resultobj = Py_None;
26414 return resultobj;
26415 fail:
26416 return NULL;
26417 }
26418
26419
26420 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26421 PyObject *resultobj;
26422 wxWindow *arg1 = (wxWindow *) 0 ;
26423 int arg2 ;
26424 int arg3 ;
26425 int arg4 = (int) -1 ;
26426 int arg5 = (int) -1 ;
26427 PyObject * obj0 = 0 ;
26428 PyObject * obj1 = 0 ;
26429 PyObject * obj2 = 0 ;
26430 PyObject * obj3 = 0 ;
26431 PyObject * obj4 = 0 ;
26432 char *kwnames[] = {
26433 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26434 };
26435
26436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26438 if (SWIG_arg_fail(1)) SWIG_fail;
26439 {
26440 arg2 = (int)(SWIG_As_int(obj1));
26441 if (SWIG_arg_fail(2)) SWIG_fail;
26442 }
26443 {
26444 arg3 = (int)(SWIG_As_int(obj2));
26445 if (SWIG_arg_fail(3)) SWIG_fail;
26446 }
26447 if (obj3) {
26448 {
26449 arg4 = (int)(SWIG_As_int(obj3));
26450 if (SWIG_arg_fail(4)) SWIG_fail;
26451 }
26452 }
26453 if (obj4) {
26454 {
26455 arg5 = (int)(SWIG_As_int(obj4));
26456 if (SWIG_arg_fail(5)) SWIG_fail;
26457 }
26458 }
26459 {
26460 PyThreadState* __tstate = wxPyBeginAllowThreads();
26461 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26462
26463 wxPyEndAllowThreads(__tstate);
26464 if (PyErr_Occurred()) SWIG_fail;
26465 }
26466 Py_INCREF(Py_None); resultobj = Py_None;
26467 return resultobj;
26468 fail:
26469 return NULL;
26470 }
26471
26472
26473 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26474 PyObject *resultobj;
26475 wxWindow *arg1 = (wxWindow *) 0 ;
26476 wxSize *arg2 = 0 ;
26477 wxSize const &arg3_defvalue = wxDefaultSize ;
26478 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26479 wxSize temp2 ;
26480 wxSize temp3 ;
26481 PyObject * obj0 = 0 ;
26482 PyObject * obj1 = 0 ;
26483 PyObject * obj2 = 0 ;
26484 char *kwnames[] = {
26485 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26486 };
26487
26488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26490 if (SWIG_arg_fail(1)) SWIG_fail;
26491 {
26492 arg2 = &temp2;
26493 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26494 }
26495 if (obj2) {
26496 {
26497 arg3 = &temp3;
26498 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26499 }
26500 }
26501 {
26502 PyThreadState* __tstate = wxPyBeginAllowThreads();
26503 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26504
26505 wxPyEndAllowThreads(__tstate);
26506 if (PyErr_Occurred()) SWIG_fail;
26507 }
26508 Py_INCREF(Py_None); resultobj = Py_None;
26509 return resultobj;
26510 fail:
26511 return NULL;
26512 }
26513
26514
26515 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26516 PyObject *resultobj;
26517 wxWindow *arg1 = (wxWindow *) 0 ;
26518 wxSize result;
26519 PyObject * obj0 = 0 ;
26520 char *kwnames[] = {
26521 (char *) "self", NULL
26522 };
26523
26524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26526 if (SWIG_arg_fail(1)) SWIG_fail;
26527 {
26528 PyThreadState* __tstate = wxPyBeginAllowThreads();
26529 result = ((wxWindow const *)arg1)->GetMaxSize();
26530
26531 wxPyEndAllowThreads(__tstate);
26532 if (PyErr_Occurred()) SWIG_fail;
26533 }
26534 {
26535 wxSize * resultptr;
26536 resultptr = new wxSize((wxSize &)(result));
26537 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26538 }
26539 return resultobj;
26540 fail:
26541 return NULL;
26542 }
26543
26544
26545 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26546 PyObject *resultobj;
26547 wxWindow *arg1 = (wxWindow *) 0 ;
26548 wxSize result;
26549 PyObject * obj0 = 0 ;
26550 char *kwnames[] = {
26551 (char *) "self", NULL
26552 };
26553
26554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26556 if (SWIG_arg_fail(1)) SWIG_fail;
26557 {
26558 PyThreadState* __tstate = wxPyBeginAllowThreads();
26559 result = ((wxWindow const *)arg1)->GetMinSize();
26560
26561 wxPyEndAllowThreads(__tstate);
26562 if (PyErr_Occurred()) SWIG_fail;
26563 }
26564 {
26565 wxSize * resultptr;
26566 resultptr = new wxSize((wxSize &)(result));
26567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26568 }
26569 return resultobj;
26570 fail:
26571 return NULL;
26572 }
26573
26574
26575 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26576 PyObject *resultobj;
26577 wxWindow *arg1 = (wxWindow *) 0 ;
26578 wxSize *arg2 = 0 ;
26579 wxSize temp2 ;
26580 PyObject * obj0 = 0 ;
26581 PyObject * obj1 = 0 ;
26582 char *kwnames[] = {
26583 (char *) "self",(char *) "minSize", NULL
26584 };
26585
26586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26588 if (SWIG_arg_fail(1)) SWIG_fail;
26589 {
26590 arg2 = &temp2;
26591 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26592 }
26593 {
26594 PyThreadState* __tstate = wxPyBeginAllowThreads();
26595 (arg1)->SetMinSize((wxSize const &)*arg2);
26596
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 Py_INCREF(Py_None); resultobj = Py_None;
26601 return resultobj;
26602 fail:
26603 return NULL;
26604 }
26605
26606
26607 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26608 PyObject *resultobj;
26609 wxWindow *arg1 = (wxWindow *) 0 ;
26610 wxSize *arg2 = 0 ;
26611 wxSize temp2 ;
26612 PyObject * obj0 = 0 ;
26613 PyObject * obj1 = 0 ;
26614 char *kwnames[] = {
26615 (char *) "self",(char *) "maxSize", NULL
26616 };
26617
26618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26620 if (SWIG_arg_fail(1)) SWIG_fail;
26621 {
26622 arg2 = &temp2;
26623 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26624 }
26625 {
26626 PyThreadState* __tstate = wxPyBeginAllowThreads();
26627 (arg1)->SetMaxSize((wxSize const &)*arg2);
26628
26629 wxPyEndAllowThreads(__tstate);
26630 if (PyErr_Occurred()) SWIG_fail;
26631 }
26632 Py_INCREF(Py_None); resultobj = Py_None;
26633 return resultobj;
26634 fail:
26635 return NULL;
26636 }
26637
26638
26639 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26640 PyObject *resultobj;
26641 wxWindow *arg1 = (wxWindow *) 0 ;
26642 int result;
26643 PyObject * obj0 = 0 ;
26644 char *kwnames[] = {
26645 (char *) "self", NULL
26646 };
26647
26648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26650 if (SWIG_arg_fail(1)) SWIG_fail;
26651 {
26652 PyThreadState* __tstate = wxPyBeginAllowThreads();
26653 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26654
26655 wxPyEndAllowThreads(__tstate);
26656 if (PyErr_Occurred()) SWIG_fail;
26657 }
26658 {
26659 resultobj = SWIG_From_int((int)(result));
26660 }
26661 return resultobj;
26662 fail:
26663 return NULL;
26664 }
26665
26666
26667 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26668 PyObject *resultobj;
26669 wxWindow *arg1 = (wxWindow *) 0 ;
26670 int result;
26671 PyObject * obj0 = 0 ;
26672 char *kwnames[] = {
26673 (char *) "self", NULL
26674 };
26675
26676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26678 if (SWIG_arg_fail(1)) SWIG_fail;
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26682
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 {
26687 resultobj = SWIG_From_int((int)(result));
26688 }
26689 return resultobj;
26690 fail:
26691 return NULL;
26692 }
26693
26694
26695 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26696 PyObject *resultobj;
26697 wxWindow *arg1 = (wxWindow *) 0 ;
26698 int result;
26699 PyObject * obj0 = 0 ;
26700 char *kwnames[] = {
26701 (char *) "self", NULL
26702 };
26703
26704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26706 if (SWIG_arg_fail(1)) SWIG_fail;
26707 {
26708 PyThreadState* __tstate = wxPyBeginAllowThreads();
26709 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26710
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 {
26715 resultobj = SWIG_From_int((int)(result));
26716 }
26717 return resultobj;
26718 fail:
26719 return NULL;
26720 }
26721
26722
26723 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26724 PyObject *resultobj;
26725 wxWindow *arg1 = (wxWindow *) 0 ;
26726 int result;
26727 PyObject * obj0 = 0 ;
26728 char *kwnames[] = {
26729 (char *) "self", NULL
26730 };
26731
26732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26737 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26738
26739 wxPyEndAllowThreads(__tstate);
26740 if (PyErr_Occurred()) SWIG_fail;
26741 }
26742 {
26743 resultobj = SWIG_From_int((int)(result));
26744 }
26745 return resultobj;
26746 fail:
26747 return NULL;
26748 }
26749
26750
26751 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26752 PyObject *resultobj;
26753 wxWindow *arg1 = (wxWindow *) 0 ;
26754 wxSize *arg2 = 0 ;
26755 wxSize temp2 ;
26756 PyObject * obj0 = 0 ;
26757 PyObject * obj1 = 0 ;
26758 char *kwnames[] = {
26759 (char *) "self",(char *) "size", NULL
26760 };
26761
26762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
26767 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26768 }
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26772
26773 wxPyEndAllowThreads(__tstate);
26774 if (PyErr_Occurred()) SWIG_fail;
26775 }
26776 Py_INCREF(Py_None); resultobj = Py_None;
26777 return resultobj;
26778 fail:
26779 return NULL;
26780 }
26781
26782
26783 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26784 PyObject *resultobj;
26785 wxWindow *arg1 = (wxWindow *) 0 ;
26786 int arg2 ;
26787 int arg3 ;
26788 PyObject * obj0 = 0 ;
26789 PyObject * obj1 = 0 ;
26790 PyObject * obj2 = 0 ;
26791 char *kwnames[] = {
26792 (char *) "self",(char *) "w",(char *) "h", NULL
26793 };
26794
26795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26797 if (SWIG_arg_fail(1)) SWIG_fail;
26798 {
26799 arg2 = (int)(SWIG_As_int(obj1));
26800 if (SWIG_arg_fail(2)) SWIG_fail;
26801 }
26802 {
26803 arg3 = (int)(SWIG_As_int(obj2));
26804 if (SWIG_arg_fail(3)) SWIG_fail;
26805 }
26806 {
26807 PyThreadState* __tstate = wxPyBeginAllowThreads();
26808 (arg1)->SetVirtualSize(arg2,arg3);
26809
26810 wxPyEndAllowThreads(__tstate);
26811 if (PyErr_Occurred()) SWIG_fail;
26812 }
26813 Py_INCREF(Py_None); resultobj = Py_None;
26814 return resultobj;
26815 fail:
26816 return NULL;
26817 }
26818
26819
26820 static PyObject *_wrap_Window_GetVirtualSize(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_GetVirtualSize",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)->GetVirtualSize();
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_GetVirtualSizeTuple(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_GetVirtualSizeTuple",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)->GetVirtualSize(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_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26888 PyObject *resultobj;
26889 wxWindow *arg1 = (wxWindow *) 0 ;
26890 wxSize result;
26891 PyObject * obj0 = 0 ;
26892 char *kwnames[] = {
26893 (char *) "self", NULL
26894 };
26895
26896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",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)->GetBestVirtualSize();
26902
26903 wxPyEndAllowThreads(__tstate);
26904 if (PyErr_Occurred()) SWIG_fail;
26905 }
26906 {
26907 wxSize * resultptr;
26908 resultptr = new wxSize((wxSize &)(result));
26909 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26910 }
26911 return resultobj;
26912 fail:
26913 return NULL;
26914 }
26915
26916
26917 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26918 PyObject *resultobj;
26919 wxWindow *arg1 = (wxWindow *) 0 ;
26920 bool arg2 = (bool) true ;
26921 bool result;
26922 PyObject * obj0 = 0 ;
26923 PyObject * obj1 = 0 ;
26924 char *kwnames[] = {
26925 (char *) "self",(char *) "show", NULL
26926 };
26927
26928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26930 if (SWIG_arg_fail(1)) SWIG_fail;
26931 if (obj1) {
26932 {
26933 arg2 = (bool)(SWIG_As_bool(obj1));
26934 if (SWIG_arg_fail(2)) SWIG_fail;
26935 }
26936 }
26937 {
26938 PyThreadState* __tstate = wxPyBeginAllowThreads();
26939 result = (bool)(arg1)->Show(arg2);
26940
26941 wxPyEndAllowThreads(__tstate);
26942 if (PyErr_Occurred()) SWIG_fail;
26943 }
26944 {
26945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26946 }
26947 return resultobj;
26948 fail:
26949 return NULL;
26950 }
26951
26952
26953 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26954 PyObject *resultobj;
26955 wxWindow *arg1 = (wxWindow *) 0 ;
26956 bool result;
26957 PyObject * obj0 = 0 ;
26958 char *kwnames[] = {
26959 (char *) "self", NULL
26960 };
26961
26962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26964 if (SWIG_arg_fail(1)) SWIG_fail;
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 result = (bool)(arg1)->Hide();
26968
26969 wxPyEndAllowThreads(__tstate);
26970 if (PyErr_Occurred()) SWIG_fail;
26971 }
26972 {
26973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26974 }
26975 return resultobj;
26976 fail:
26977 return NULL;
26978 }
26979
26980
26981 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26982 PyObject *resultobj;
26983 wxWindow *arg1 = (wxWindow *) 0 ;
26984 bool arg2 = (bool) true ;
26985 bool result;
26986 PyObject * obj0 = 0 ;
26987 PyObject * obj1 = 0 ;
26988 char *kwnames[] = {
26989 (char *) "self",(char *) "enable", NULL
26990 };
26991
26992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26994 if (SWIG_arg_fail(1)) SWIG_fail;
26995 if (obj1) {
26996 {
26997 arg2 = (bool)(SWIG_As_bool(obj1));
26998 if (SWIG_arg_fail(2)) SWIG_fail;
26999 }
27000 }
27001 {
27002 PyThreadState* __tstate = wxPyBeginAllowThreads();
27003 result = (bool)(arg1)->Enable(arg2);
27004
27005 wxPyEndAllowThreads(__tstate);
27006 if (PyErr_Occurred()) SWIG_fail;
27007 }
27008 {
27009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27010 }
27011 return resultobj;
27012 fail:
27013 return NULL;
27014 }
27015
27016
27017 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27018 PyObject *resultobj;
27019 wxWindow *arg1 = (wxWindow *) 0 ;
27020 bool result;
27021 PyObject * obj0 = 0 ;
27022 char *kwnames[] = {
27023 (char *) "self", NULL
27024 };
27025
27026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27028 if (SWIG_arg_fail(1)) SWIG_fail;
27029 {
27030 PyThreadState* __tstate = wxPyBeginAllowThreads();
27031 result = (bool)(arg1)->Disable();
27032
27033 wxPyEndAllowThreads(__tstate);
27034 if (PyErr_Occurred()) SWIG_fail;
27035 }
27036 {
27037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27038 }
27039 return resultobj;
27040 fail:
27041 return NULL;
27042 }
27043
27044
27045 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27046 PyObject *resultobj;
27047 wxWindow *arg1 = (wxWindow *) 0 ;
27048 bool result;
27049 PyObject * obj0 = 0 ;
27050 char *kwnames[] = {
27051 (char *) "self", NULL
27052 };
27053
27054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27056 if (SWIG_arg_fail(1)) SWIG_fail;
27057 {
27058 PyThreadState* __tstate = wxPyBeginAllowThreads();
27059 result = (bool)((wxWindow const *)arg1)->IsShown();
27060
27061 wxPyEndAllowThreads(__tstate);
27062 if (PyErr_Occurred()) SWIG_fail;
27063 }
27064 {
27065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27066 }
27067 return resultobj;
27068 fail:
27069 return NULL;
27070 }
27071
27072
27073 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27074 PyObject *resultobj;
27075 wxWindow *arg1 = (wxWindow *) 0 ;
27076 bool result;
27077 PyObject * obj0 = 0 ;
27078 char *kwnames[] = {
27079 (char *) "self", NULL
27080 };
27081
27082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27084 if (SWIG_arg_fail(1)) SWIG_fail;
27085 {
27086 PyThreadState* __tstate = wxPyBeginAllowThreads();
27087 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27088
27089 wxPyEndAllowThreads(__tstate);
27090 if (PyErr_Occurred()) SWIG_fail;
27091 }
27092 {
27093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27094 }
27095 return resultobj;
27096 fail:
27097 return NULL;
27098 }
27099
27100
27101 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27102 PyObject *resultobj;
27103 wxWindow *arg1 = (wxWindow *) 0 ;
27104 long arg2 ;
27105 PyObject * obj0 = 0 ;
27106 PyObject * obj1 = 0 ;
27107 char *kwnames[] = {
27108 (char *) "self",(char *) "style", NULL
27109 };
27110
27111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27113 if (SWIG_arg_fail(1)) SWIG_fail;
27114 {
27115 arg2 = (long)(SWIG_As_long(obj1));
27116 if (SWIG_arg_fail(2)) SWIG_fail;
27117 }
27118 {
27119 PyThreadState* __tstate = wxPyBeginAllowThreads();
27120 (arg1)->SetWindowStyleFlag(arg2);
27121
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 Py_INCREF(Py_None); resultobj = Py_None;
27126 return resultobj;
27127 fail:
27128 return NULL;
27129 }
27130
27131
27132 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27133 PyObject *resultobj;
27134 wxWindow *arg1 = (wxWindow *) 0 ;
27135 long result;
27136 PyObject * obj0 = 0 ;
27137 char *kwnames[] = {
27138 (char *) "self", NULL
27139 };
27140
27141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27143 if (SWIG_arg_fail(1)) SWIG_fail;
27144 {
27145 PyThreadState* __tstate = wxPyBeginAllowThreads();
27146 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27147
27148 wxPyEndAllowThreads(__tstate);
27149 if (PyErr_Occurred()) SWIG_fail;
27150 }
27151 {
27152 resultobj = SWIG_From_long((long)(result));
27153 }
27154 return resultobj;
27155 fail:
27156 return NULL;
27157 }
27158
27159
27160 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27161 PyObject *resultobj;
27162 wxWindow *arg1 = (wxWindow *) 0 ;
27163 int arg2 ;
27164 bool result;
27165 PyObject * obj0 = 0 ;
27166 PyObject * obj1 = 0 ;
27167 char *kwnames[] = {
27168 (char *) "self",(char *) "flag", NULL
27169 };
27170
27171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27173 if (SWIG_arg_fail(1)) SWIG_fail;
27174 {
27175 arg2 = (int)(SWIG_As_int(obj1));
27176 if (SWIG_arg_fail(2)) SWIG_fail;
27177 }
27178 {
27179 PyThreadState* __tstate = wxPyBeginAllowThreads();
27180 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27181
27182 wxPyEndAllowThreads(__tstate);
27183 if (PyErr_Occurred()) SWIG_fail;
27184 }
27185 {
27186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27187 }
27188 return resultobj;
27189 fail:
27190 return NULL;
27191 }
27192
27193
27194 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27195 PyObject *resultobj;
27196 wxWindow *arg1 = (wxWindow *) 0 ;
27197 bool result;
27198 PyObject * obj0 = 0 ;
27199 char *kwnames[] = {
27200 (char *) "self", NULL
27201 };
27202
27203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27205 if (SWIG_arg_fail(1)) SWIG_fail;
27206 {
27207 PyThreadState* __tstate = wxPyBeginAllowThreads();
27208 result = (bool)((wxWindow const *)arg1)->IsRetained();
27209
27210 wxPyEndAllowThreads(__tstate);
27211 if (PyErr_Occurred()) SWIG_fail;
27212 }
27213 {
27214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27215 }
27216 return resultobj;
27217 fail:
27218 return NULL;
27219 }
27220
27221
27222 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27223 PyObject *resultobj;
27224 wxWindow *arg1 = (wxWindow *) 0 ;
27225 long arg2 ;
27226 PyObject * obj0 = 0 ;
27227 PyObject * obj1 = 0 ;
27228 char *kwnames[] = {
27229 (char *) "self",(char *) "exStyle", NULL
27230 };
27231
27232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27234 if (SWIG_arg_fail(1)) SWIG_fail;
27235 {
27236 arg2 = (long)(SWIG_As_long(obj1));
27237 if (SWIG_arg_fail(2)) SWIG_fail;
27238 }
27239 {
27240 PyThreadState* __tstate = wxPyBeginAllowThreads();
27241 (arg1)->SetExtraStyle(arg2);
27242
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 Py_INCREF(Py_None); resultobj = Py_None;
27247 return resultobj;
27248 fail:
27249 return NULL;
27250 }
27251
27252
27253 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27254 PyObject *resultobj;
27255 wxWindow *arg1 = (wxWindow *) 0 ;
27256 long result;
27257 PyObject * obj0 = 0 ;
27258 char *kwnames[] = {
27259 (char *) "self", NULL
27260 };
27261
27262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27264 if (SWIG_arg_fail(1)) SWIG_fail;
27265 {
27266 PyThreadState* __tstate = wxPyBeginAllowThreads();
27267 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27268
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 {
27273 resultobj = SWIG_From_long((long)(result));
27274 }
27275 return resultobj;
27276 fail:
27277 return NULL;
27278 }
27279
27280
27281 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27282 PyObject *resultobj;
27283 wxWindow *arg1 = (wxWindow *) 0 ;
27284 bool arg2 = (bool) true ;
27285 PyObject * obj0 = 0 ;
27286 PyObject * obj1 = 0 ;
27287 char *kwnames[] = {
27288 (char *) "self",(char *) "modal", NULL
27289 };
27290
27291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27293 if (SWIG_arg_fail(1)) SWIG_fail;
27294 if (obj1) {
27295 {
27296 arg2 = (bool)(SWIG_As_bool(obj1));
27297 if (SWIG_arg_fail(2)) SWIG_fail;
27298 }
27299 }
27300 {
27301 PyThreadState* __tstate = wxPyBeginAllowThreads();
27302 (arg1)->MakeModal(arg2);
27303
27304 wxPyEndAllowThreads(__tstate);
27305 if (PyErr_Occurred()) SWIG_fail;
27306 }
27307 Py_INCREF(Py_None); resultobj = Py_None;
27308 return resultobj;
27309 fail:
27310 return NULL;
27311 }
27312
27313
27314 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27315 PyObject *resultobj;
27316 wxWindow *arg1 = (wxWindow *) 0 ;
27317 bool arg2 ;
27318 PyObject * obj0 = 0 ;
27319 PyObject * obj1 = 0 ;
27320 char *kwnames[] = {
27321 (char *) "self",(char *) "enableTheme", NULL
27322 };
27323
27324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27326 if (SWIG_arg_fail(1)) SWIG_fail;
27327 {
27328 arg2 = (bool)(SWIG_As_bool(obj1));
27329 if (SWIG_arg_fail(2)) SWIG_fail;
27330 }
27331 {
27332 PyThreadState* __tstate = wxPyBeginAllowThreads();
27333 (arg1)->SetThemeEnabled(arg2);
27334
27335 wxPyEndAllowThreads(__tstate);
27336 if (PyErr_Occurred()) SWIG_fail;
27337 }
27338 Py_INCREF(Py_None); resultobj = Py_None;
27339 return resultobj;
27340 fail:
27341 return NULL;
27342 }
27343
27344
27345 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27346 PyObject *resultobj;
27347 wxWindow *arg1 = (wxWindow *) 0 ;
27348 bool result;
27349 PyObject * obj0 = 0 ;
27350 char *kwnames[] = {
27351 (char *) "self", NULL
27352 };
27353
27354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27356 if (SWIG_arg_fail(1)) SWIG_fail;
27357 {
27358 PyThreadState* __tstate = wxPyBeginAllowThreads();
27359 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27360
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 {
27365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27366 }
27367 return resultobj;
27368 fail:
27369 return NULL;
27370 }
27371
27372
27373 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27374 PyObject *resultobj;
27375 wxWindow *arg1 = (wxWindow *) 0 ;
27376 PyObject * obj0 = 0 ;
27377 char *kwnames[] = {
27378 (char *) "self", NULL
27379 };
27380
27381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27383 if (SWIG_arg_fail(1)) SWIG_fail;
27384 {
27385 PyThreadState* __tstate = wxPyBeginAllowThreads();
27386 (arg1)->SetFocus();
27387
27388 wxPyEndAllowThreads(__tstate);
27389 if (PyErr_Occurred()) SWIG_fail;
27390 }
27391 Py_INCREF(Py_None); resultobj = Py_None;
27392 return resultobj;
27393 fail:
27394 return NULL;
27395 }
27396
27397
27398 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27399 PyObject *resultobj;
27400 wxWindow *arg1 = (wxWindow *) 0 ;
27401 PyObject * obj0 = 0 ;
27402 char *kwnames[] = {
27403 (char *) "self", NULL
27404 };
27405
27406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27408 if (SWIG_arg_fail(1)) SWIG_fail;
27409 {
27410 PyThreadState* __tstate = wxPyBeginAllowThreads();
27411 (arg1)->SetFocusFromKbd();
27412
27413 wxPyEndAllowThreads(__tstate);
27414 if (PyErr_Occurred()) SWIG_fail;
27415 }
27416 Py_INCREF(Py_None); resultobj = Py_None;
27417 return resultobj;
27418 fail:
27419 return NULL;
27420 }
27421
27422
27423 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27424 PyObject *resultobj;
27425 wxWindow *result;
27426 char *kwnames[] = {
27427 NULL
27428 };
27429
27430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27431 {
27432 if (!wxPyCheckForApp()) SWIG_fail;
27433 PyThreadState* __tstate = wxPyBeginAllowThreads();
27434 result = (wxWindow *)wxWindow::FindFocus();
27435
27436 wxPyEndAllowThreads(__tstate);
27437 if (PyErr_Occurred()) SWIG_fail;
27438 }
27439 {
27440 resultobj = wxPyMake_wxObject(result, 0);
27441 }
27442 return resultobj;
27443 fail:
27444 return NULL;
27445 }
27446
27447
27448 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27449 PyObject *resultobj;
27450 wxWindow *arg1 = (wxWindow *) 0 ;
27451 bool result;
27452 PyObject * obj0 = 0 ;
27453 char *kwnames[] = {
27454 (char *) "self", NULL
27455 };
27456
27457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27459 if (SWIG_arg_fail(1)) SWIG_fail;
27460 {
27461 PyThreadState* __tstate = wxPyBeginAllowThreads();
27462 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27463
27464 wxPyEndAllowThreads(__tstate);
27465 if (PyErr_Occurred()) SWIG_fail;
27466 }
27467 {
27468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27469 }
27470 return resultobj;
27471 fail:
27472 return NULL;
27473 }
27474
27475
27476 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27477 PyObject *resultobj;
27478 wxWindow *arg1 = (wxWindow *) 0 ;
27479 bool result;
27480 PyObject * obj0 = 0 ;
27481 char *kwnames[] = {
27482 (char *) "self", NULL
27483 };
27484
27485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27487 if (SWIG_arg_fail(1)) SWIG_fail;
27488 {
27489 PyThreadState* __tstate = wxPyBeginAllowThreads();
27490 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27491
27492 wxPyEndAllowThreads(__tstate);
27493 if (PyErr_Occurred()) SWIG_fail;
27494 }
27495 {
27496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27497 }
27498 return resultobj;
27499 fail:
27500 return NULL;
27501 }
27502
27503
27504 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27505 PyObject *resultobj;
27506 wxWindow *arg1 = (wxWindow *) 0 ;
27507 wxWindow *result;
27508 PyObject * obj0 = 0 ;
27509 char *kwnames[] = {
27510 (char *) "self", NULL
27511 };
27512
27513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27515 if (SWIG_arg_fail(1)) SWIG_fail;
27516 {
27517 PyThreadState* __tstate = wxPyBeginAllowThreads();
27518 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27519
27520 wxPyEndAllowThreads(__tstate);
27521 if (PyErr_Occurred()) SWIG_fail;
27522 }
27523 {
27524 resultobj = wxPyMake_wxObject(result, 0);
27525 }
27526 return resultobj;
27527 fail:
27528 return NULL;
27529 }
27530
27531
27532 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27533 PyObject *resultobj;
27534 wxWindow *arg1 = (wxWindow *) 0 ;
27535 wxWindow *arg2 = (wxWindow *) 0 ;
27536 wxWindow *result;
27537 PyObject * obj0 = 0 ;
27538 PyObject * obj1 = 0 ;
27539 char *kwnames[] = {
27540 (char *) "self",(char *) "child", NULL
27541 };
27542
27543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27545 if (SWIG_arg_fail(1)) SWIG_fail;
27546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27547 if (SWIG_arg_fail(2)) SWIG_fail;
27548 {
27549 PyThreadState* __tstate = wxPyBeginAllowThreads();
27550 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27551
27552 wxPyEndAllowThreads(__tstate);
27553 if (PyErr_Occurred()) SWIG_fail;
27554 }
27555 {
27556 resultobj = wxPyMake_wxObject(result, 0);
27557 }
27558 return resultobj;
27559 fail:
27560 return NULL;
27561 }
27562
27563
27564 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27565 PyObject *resultobj;
27566 wxWindow *arg1 = (wxWindow *) 0 ;
27567 wxWindow *arg2 = (wxWindow *) 0 ;
27568 PyObject * obj0 = 0 ;
27569 PyObject * obj1 = 0 ;
27570 char *kwnames[] = {
27571 (char *) "self",(char *) "win", NULL
27572 };
27573
27574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27576 if (SWIG_arg_fail(1)) SWIG_fail;
27577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27578 if (SWIG_arg_fail(2)) SWIG_fail;
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 (arg1)->SetTmpDefaultItem(arg2);
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_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj;
27595 wxWindow *arg1 = (wxWindow *) 0 ;
27596 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27597 bool result;
27598 PyObject * obj0 = 0 ;
27599 PyObject * obj1 = 0 ;
27600 char *kwnames[] = {
27601 (char *) "self",(char *) "flags", NULL
27602 };
27603
27604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27606 if (SWIG_arg_fail(1)) SWIG_fail;
27607 if (obj1) {
27608 {
27609 arg2 = (int)(SWIG_As_int(obj1));
27610 if (SWIG_arg_fail(2)) SWIG_fail;
27611 }
27612 }
27613 {
27614 PyThreadState* __tstate = wxPyBeginAllowThreads();
27615 result = (bool)(arg1)->Navigate(arg2);
27616
27617 wxPyEndAllowThreads(__tstate);
27618 if (PyErr_Occurred()) SWIG_fail;
27619 }
27620 {
27621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27622 }
27623 return resultobj;
27624 fail:
27625 return NULL;
27626 }
27627
27628
27629 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27630 PyObject *resultobj;
27631 wxWindow *arg1 = (wxWindow *) 0 ;
27632 wxWindow *arg2 = (wxWindow *) 0 ;
27633 PyObject * obj0 = 0 ;
27634 PyObject * obj1 = 0 ;
27635 char *kwnames[] = {
27636 (char *) "self",(char *) "win", NULL
27637 };
27638
27639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27641 if (SWIG_arg_fail(1)) SWIG_fail;
27642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27643 if (SWIG_arg_fail(2)) SWIG_fail;
27644 {
27645 PyThreadState* __tstate = wxPyBeginAllowThreads();
27646 (arg1)->MoveAfterInTabOrder(arg2);
27647
27648 wxPyEndAllowThreads(__tstate);
27649 if (PyErr_Occurred()) SWIG_fail;
27650 }
27651 Py_INCREF(Py_None); resultobj = Py_None;
27652 return resultobj;
27653 fail:
27654 return NULL;
27655 }
27656
27657
27658 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27659 PyObject *resultobj;
27660 wxWindow *arg1 = (wxWindow *) 0 ;
27661 wxWindow *arg2 = (wxWindow *) 0 ;
27662 PyObject * obj0 = 0 ;
27663 PyObject * obj1 = 0 ;
27664 char *kwnames[] = {
27665 (char *) "self",(char *) "win", NULL
27666 };
27667
27668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27670 if (SWIG_arg_fail(1)) SWIG_fail;
27671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27672 if (SWIG_arg_fail(2)) SWIG_fail;
27673 {
27674 PyThreadState* __tstate = wxPyBeginAllowThreads();
27675 (arg1)->MoveBeforeInTabOrder(arg2);
27676
27677 wxPyEndAllowThreads(__tstate);
27678 if (PyErr_Occurred()) SWIG_fail;
27679 }
27680 Py_INCREF(Py_None); resultobj = Py_None;
27681 return resultobj;
27682 fail:
27683 return NULL;
27684 }
27685
27686
27687 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27688 PyObject *resultobj;
27689 wxWindow *arg1 = (wxWindow *) 0 ;
27690 PyObject *result;
27691 PyObject * obj0 = 0 ;
27692 char *kwnames[] = {
27693 (char *) "self", NULL
27694 };
27695
27696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
27701 result = (PyObject *)wxWindow_GetChildren(arg1);
27702
27703 wxPyEndAllowThreads(__tstate);
27704 if (PyErr_Occurred()) SWIG_fail;
27705 }
27706 resultobj = result;
27707 return resultobj;
27708 fail:
27709 return NULL;
27710 }
27711
27712
27713 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27714 PyObject *resultobj;
27715 wxWindow *arg1 = (wxWindow *) 0 ;
27716 wxWindow *result;
27717 PyObject * obj0 = 0 ;
27718 char *kwnames[] = {
27719 (char *) "self", NULL
27720 };
27721
27722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27724 if (SWIG_arg_fail(1)) SWIG_fail;
27725 {
27726 PyThreadState* __tstate = wxPyBeginAllowThreads();
27727 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27728
27729 wxPyEndAllowThreads(__tstate);
27730 if (PyErr_Occurred()) SWIG_fail;
27731 }
27732 {
27733 resultobj = wxPyMake_wxObject(result, 0);
27734 }
27735 return resultobj;
27736 fail:
27737 return NULL;
27738 }
27739
27740
27741 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27742 PyObject *resultobj;
27743 wxWindow *arg1 = (wxWindow *) 0 ;
27744 wxWindow *result;
27745 PyObject * obj0 = 0 ;
27746 char *kwnames[] = {
27747 (char *) "self", NULL
27748 };
27749
27750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27752 if (SWIG_arg_fail(1)) SWIG_fail;
27753 {
27754 PyThreadState* __tstate = wxPyBeginAllowThreads();
27755 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27756
27757 wxPyEndAllowThreads(__tstate);
27758 if (PyErr_Occurred()) SWIG_fail;
27759 }
27760 {
27761 resultobj = wxPyMake_wxObject(result, 0);
27762 }
27763 return resultobj;
27764 fail:
27765 return NULL;
27766 }
27767
27768
27769 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27770 PyObject *resultobj;
27771 wxWindow *arg1 = (wxWindow *) 0 ;
27772 bool result;
27773 PyObject * obj0 = 0 ;
27774 char *kwnames[] = {
27775 (char *) "self", NULL
27776 };
27777
27778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27780 if (SWIG_arg_fail(1)) SWIG_fail;
27781 {
27782 PyThreadState* __tstate = wxPyBeginAllowThreads();
27783 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27784
27785 wxPyEndAllowThreads(__tstate);
27786 if (PyErr_Occurred()) SWIG_fail;
27787 }
27788 {
27789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27790 }
27791 return resultobj;
27792 fail:
27793 return NULL;
27794 }
27795
27796
27797 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27798 PyObject *resultobj;
27799 wxWindow *arg1 = (wxWindow *) 0 ;
27800 wxWindow *arg2 = (wxWindow *) 0 ;
27801 bool result;
27802 PyObject * obj0 = 0 ;
27803 PyObject * obj1 = 0 ;
27804 char *kwnames[] = {
27805 (char *) "self",(char *) "newParent", NULL
27806 };
27807
27808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27810 if (SWIG_arg_fail(1)) SWIG_fail;
27811 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27812 if (SWIG_arg_fail(2)) SWIG_fail;
27813 {
27814 PyThreadState* __tstate = wxPyBeginAllowThreads();
27815 result = (bool)(arg1)->Reparent(arg2);
27816
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 {
27821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27822 }
27823 return resultobj;
27824 fail:
27825 return NULL;
27826 }
27827
27828
27829 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27830 PyObject *resultobj;
27831 wxWindow *arg1 = (wxWindow *) 0 ;
27832 wxWindow *arg2 = (wxWindow *) 0 ;
27833 PyObject * obj0 = 0 ;
27834 PyObject * obj1 = 0 ;
27835 char *kwnames[] = {
27836 (char *) "self",(char *) "child", NULL
27837 };
27838
27839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27841 if (SWIG_arg_fail(1)) SWIG_fail;
27842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27843 if (SWIG_arg_fail(2)) SWIG_fail;
27844 {
27845 PyThreadState* __tstate = wxPyBeginAllowThreads();
27846 (arg1)->AddChild(arg2);
27847
27848 wxPyEndAllowThreads(__tstate);
27849 if (PyErr_Occurred()) SWIG_fail;
27850 }
27851 Py_INCREF(Py_None); resultobj = Py_None;
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27859 PyObject *resultobj;
27860 wxWindow *arg1 = (wxWindow *) 0 ;
27861 wxWindow *arg2 = (wxWindow *) 0 ;
27862 PyObject * obj0 = 0 ;
27863 PyObject * obj1 = 0 ;
27864 char *kwnames[] = {
27865 (char *) "self",(char *) "child", NULL
27866 };
27867
27868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27870 if (SWIG_arg_fail(1)) SWIG_fail;
27871 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27872 if (SWIG_arg_fail(2)) SWIG_fail;
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 (arg1)->RemoveChild(arg2);
27876
27877 wxPyEndAllowThreads(__tstate);
27878 if (PyErr_Occurred()) SWIG_fail;
27879 }
27880 Py_INCREF(Py_None); resultobj = Py_None;
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27888 PyObject *resultobj;
27889 wxWindow *arg1 = (wxWindow *) 0 ;
27890 long arg2 ;
27891 wxWindow *result;
27892 PyObject * obj0 = 0 ;
27893 PyObject * obj1 = 0 ;
27894 char *kwnames[] = {
27895 (char *) "self",(char *) "winid", NULL
27896 };
27897
27898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27900 if (SWIG_arg_fail(1)) SWIG_fail;
27901 {
27902 arg2 = (long)(SWIG_As_long(obj1));
27903 if (SWIG_arg_fail(2)) SWIG_fail;
27904 }
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 result = (wxWindow *)(arg1)->FindWindow(arg2);
27908
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 {
27913 resultobj = wxPyMake_wxObject(result, 0);
27914 }
27915 return resultobj;
27916 fail:
27917 return NULL;
27918 }
27919
27920
27921 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27922 PyObject *resultobj;
27923 wxWindow *arg1 = (wxWindow *) 0 ;
27924 wxString *arg2 = 0 ;
27925 wxWindow *result;
27926 bool temp2 = false ;
27927 PyObject * obj0 = 0 ;
27928 PyObject * obj1 = 0 ;
27929 char *kwnames[] = {
27930 (char *) "self",(char *) "name", NULL
27931 };
27932
27933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27935 if (SWIG_arg_fail(1)) SWIG_fail;
27936 {
27937 arg2 = wxString_in_helper(obj1);
27938 if (arg2 == NULL) SWIG_fail;
27939 temp2 = true;
27940 }
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27944
27945 wxPyEndAllowThreads(__tstate);
27946 if (PyErr_Occurred()) SWIG_fail;
27947 }
27948 {
27949 resultobj = wxPyMake_wxObject(result, 0);
27950 }
27951 {
27952 if (temp2)
27953 delete arg2;
27954 }
27955 return resultobj;
27956 fail:
27957 {
27958 if (temp2)
27959 delete arg2;
27960 }
27961 return NULL;
27962 }
27963
27964
27965 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj;
27967 wxWindow *arg1 = (wxWindow *) 0 ;
27968 wxEvtHandler *result;
27969 PyObject * obj0 = 0 ;
27970 char *kwnames[] = {
27971 (char *) "self", NULL
27972 };
27973
27974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",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 = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27980
27981 wxPyEndAllowThreads(__tstate);
27982 if (PyErr_Occurred()) SWIG_fail;
27983 }
27984 {
27985 resultobj = wxPyMake_wxObject(result, 0);
27986 }
27987 return resultobj;
27988 fail:
27989 return NULL;
27990 }
27991
27992
27993 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27994 PyObject *resultobj;
27995 wxWindow *arg1 = (wxWindow *) 0 ;
27996 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27997 PyObject * obj0 = 0 ;
27998 PyObject * obj1 = 0 ;
27999 char *kwnames[] = {
28000 (char *) "self",(char *) "handler", NULL
28001 };
28002
28003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28005 if (SWIG_arg_fail(1)) SWIG_fail;
28006 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28007 if (SWIG_arg_fail(2)) SWIG_fail;
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 (arg1)->SetEventHandler(arg2);
28011
28012 wxPyEndAllowThreads(__tstate);
28013 if (PyErr_Occurred()) SWIG_fail;
28014 }
28015 Py_INCREF(Py_None); resultobj = Py_None;
28016 return resultobj;
28017 fail:
28018 return NULL;
28019 }
28020
28021
28022 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28023 PyObject *resultobj;
28024 wxWindow *arg1 = (wxWindow *) 0 ;
28025 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28026 PyObject * obj0 = 0 ;
28027 PyObject * obj1 = 0 ;
28028 char *kwnames[] = {
28029 (char *) "self",(char *) "handler", NULL
28030 };
28031
28032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28034 if (SWIG_arg_fail(1)) SWIG_fail;
28035 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28036 if (SWIG_arg_fail(2)) SWIG_fail;
28037 {
28038 PyThreadState* __tstate = wxPyBeginAllowThreads();
28039 (arg1)->PushEventHandler(arg2);
28040
28041 wxPyEndAllowThreads(__tstate);
28042 if (PyErr_Occurred()) SWIG_fail;
28043 }
28044 Py_INCREF(Py_None); resultobj = Py_None;
28045 return resultobj;
28046 fail:
28047 return NULL;
28048 }
28049
28050
28051 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28052 PyObject *resultobj;
28053 wxWindow *arg1 = (wxWindow *) 0 ;
28054 bool arg2 = (bool) false ;
28055 wxEvtHandler *result;
28056 PyObject * obj0 = 0 ;
28057 PyObject * obj1 = 0 ;
28058 char *kwnames[] = {
28059 (char *) "self",(char *) "deleteHandler", NULL
28060 };
28061
28062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28064 if (SWIG_arg_fail(1)) SWIG_fail;
28065 if (obj1) {
28066 {
28067 arg2 = (bool)(SWIG_As_bool(obj1));
28068 if (SWIG_arg_fail(2)) SWIG_fail;
28069 }
28070 }
28071 {
28072 PyThreadState* __tstate = wxPyBeginAllowThreads();
28073 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28074
28075 wxPyEndAllowThreads(__tstate);
28076 if (PyErr_Occurred()) SWIG_fail;
28077 }
28078 {
28079 resultobj = wxPyMake_wxObject(result, 0);
28080 }
28081 return resultobj;
28082 fail:
28083 return NULL;
28084 }
28085
28086
28087 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28088 PyObject *resultobj;
28089 wxWindow *arg1 = (wxWindow *) 0 ;
28090 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28091 bool result;
28092 PyObject * obj0 = 0 ;
28093 PyObject * obj1 = 0 ;
28094 char *kwnames[] = {
28095 (char *) "self",(char *) "handler", NULL
28096 };
28097
28098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28100 if (SWIG_arg_fail(1)) SWIG_fail;
28101 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28102 if (SWIG_arg_fail(2)) SWIG_fail;
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 result = (bool)(arg1)->RemoveEventHandler(arg2);
28106
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 {
28111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28112 }
28113 return resultobj;
28114 fail:
28115 return NULL;
28116 }
28117
28118
28119 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28120 PyObject *resultobj;
28121 wxWindow *arg1 = (wxWindow *) 0 ;
28122 wxValidator *arg2 = 0 ;
28123 PyObject * obj0 = 0 ;
28124 PyObject * obj1 = 0 ;
28125 char *kwnames[] = {
28126 (char *) "self",(char *) "validator", NULL
28127 };
28128
28129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28131 if (SWIG_arg_fail(1)) SWIG_fail;
28132 {
28133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28134 if (SWIG_arg_fail(2)) SWIG_fail;
28135 if (arg2 == NULL) {
28136 SWIG_null_ref("wxValidator");
28137 }
28138 if (SWIG_arg_fail(2)) SWIG_fail;
28139 }
28140 {
28141 PyThreadState* __tstate = wxPyBeginAllowThreads();
28142 (arg1)->SetValidator((wxValidator const &)*arg2);
28143
28144 wxPyEndAllowThreads(__tstate);
28145 if (PyErr_Occurred()) SWIG_fail;
28146 }
28147 Py_INCREF(Py_None); resultobj = Py_None;
28148 return resultobj;
28149 fail:
28150 return NULL;
28151 }
28152
28153
28154 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28155 PyObject *resultobj;
28156 wxWindow *arg1 = (wxWindow *) 0 ;
28157 wxValidator *result;
28158 PyObject * obj0 = 0 ;
28159 char *kwnames[] = {
28160 (char *) "self", NULL
28161 };
28162
28163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28165 if (SWIG_arg_fail(1)) SWIG_fail;
28166 {
28167 PyThreadState* __tstate = wxPyBeginAllowThreads();
28168 result = (wxValidator *)(arg1)->GetValidator();
28169
28170 wxPyEndAllowThreads(__tstate);
28171 if (PyErr_Occurred()) SWIG_fail;
28172 }
28173 {
28174 resultobj = wxPyMake_wxObject(result, 0);
28175 }
28176 return resultobj;
28177 fail:
28178 return NULL;
28179 }
28180
28181
28182 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28183 PyObject *resultobj;
28184 wxWindow *arg1 = (wxWindow *) 0 ;
28185 bool result;
28186 PyObject * obj0 = 0 ;
28187 char *kwnames[] = {
28188 (char *) "self", NULL
28189 };
28190
28191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28193 if (SWIG_arg_fail(1)) SWIG_fail;
28194 {
28195 PyThreadState* __tstate = wxPyBeginAllowThreads();
28196 result = (bool)(arg1)->Validate();
28197
28198 wxPyEndAllowThreads(__tstate);
28199 if (PyErr_Occurred()) SWIG_fail;
28200 }
28201 {
28202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28203 }
28204 return resultobj;
28205 fail:
28206 return NULL;
28207 }
28208
28209
28210 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28211 PyObject *resultobj;
28212 wxWindow *arg1 = (wxWindow *) 0 ;
28213 bool result;
28214 PyObject * obj0 = 0 ;
28215 char *kwnames[] = {
28216 (char *) "self", NULL
28217 };
28218
28219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",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 = (bool)(arg1)->TransferDataToWindow();
28225
28226 wxPyEndAllowThreads(__tstate);
28227 if (PyErr_Occurred()) SWIG_fail;
28228 }
28229 {
28230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28231 }
28232 return resultobj;
28233 fail:
28234 return NULL;
28235 }
28236
28237
28238 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28239 PyObject *resultobj;
28240 wxWindow *arg1 = (wxWindow *) 0 ;
28241 bool result;
28242 PyObject * obj0 = 0 ;
28243 char *kwnames[] = {
28244 (char *) "self", NULL
28245 };
28246
28247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28249 if (SWIG_arg_fail(1)) SWIG_fail;
28250 {
28251 PyThreadState* __tstate = wxPyBeginAllowThreads();
28252 result = (bool)(arg1)->TransferDataFromWindow();
28253
28254 wxPyEndAllowThreads(__tstate);
28255 if (PyErr_Occurred()) SWIG_fail;
28256 }
28257 {
28258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28259 }
28260 return resultobj;
28261 fail:
28262 return NULL;
28263 }
28264
28265
28266 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28267 PyObject *resultobj;
28268 wxWindow *arg1 = (wxWindow *) 0 ;
28269 PyObject * obj0 = 0 ;
28270 char *kwnames[] = {
28271 (char *) "self", NULL
28272 };
28273
28274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28276 if (SWIG_arg_fail(1)) SWIG_fail;
28277 {
28278 PyThreadState* __tstate = wxPyBeginAllowThreads();
28279 (arg1)->InitDialog();
28280
28281 wxPyEndAllowThreads(__tstate);
28282 if (PyErr_Occurred()) SWIG_fail;
28283 }
28284 Py_INCREF(Py_None); resultobj = Py_None;
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28292 PyObject *resultobj;
28293 wxWindow *arg1 = (wxWindow *) 0 ;
28294 wxAcceleratorTable *arg2 = 0 ;
28295 PyObject * obj0 = 0 ;
28296 PyObject * obj1 = 0 ;
28297 char *kwnames[] = {
28298 (char *) "self",(char *) "accel", NULL
28299 };
28300
28301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28303 if (SWIG_arg_fail(1)) SWIG_fail;
28304 {
28305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28306 if (SWIG_arg_fail(2)) SWIG_fail;
28307 if (arg2 == NULL) {
28308 SWIG_null_ref("wxAcceleratorTable");
28309 }
28310 if (SWIG_arg_fail(2)) SWIG_fail;
28311 }
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28315
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 Py_INCREF(Py_None); resultobj = Py_None;
28320 return resultobj;
28321 fail:
28322 return NULL;
28323 }
28324
28325
28326 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28327 PyObject *resultobj;
28328 wxWindow *arg1 = (wxWindow *) 0 ;
28329 wxAcceleratorTable *result;
28330 PyObject * obj0 = 0 ;
28331 char *kwnames[] = {
28332 (char *) "self", NULL
28333 };
28334
28335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28337 if (SWIG_arg_fail(1)) SWIG_fail;
28338 {
28339 PyThreadState* __tstate = wxPyBeginAllowThreads();
28340 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28341
28342 wxPyEndAllowThreads(__tstate);
28343 if (PyErr_Occurred()) SWIG_fail;
28344 }
28345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28346 return resultobj;
28347 fail:
28348 return NULL;
28349 }
28350
28351
28352 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28353 PyObject *resultobj;
28354 wxWindow *arg1 = (wxWindow *) 0 ;
28355 int arg2 ;
28356 int arg3 ;
28357 int arg4 ;
28358 bool result;
28359 PyObject * obj0 = 0 ;
28360 PyObject * obj1 = 0 ;
28361 PyObject * obj2 = 0 ;
28362 PyObject * obj3 = 0 ;
28363 char *kwnames[] = {
28364 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28365 };
28366
28367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28369 if (SWIG_arg_fail(1)) SWIG_fail;
28370 {
28371 arg2 = (int)(SWIG_As_int(obj1));
28372 if (SWIG_arg_fail(2)) SWIG_fail;
28373 }
28374 {
28375 arg3 = (int)(SWIG_As_int(obj2));
28376 if (SWIG_arg_fail(3)) SWIG_fail;
28377 }
28378 {
28379 arg4 = (int)(SWIG_As_int(obj3));
28380 if (SWIG_arg_fail(4)) SWIG_fail;
28381 }
28382 {
28383 PyThreadState* __tstate = wxPyBeginAllowThreads();
28384 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28385
28386 wxPyEndAllowThreads(__tstate);
28387 if (PyErr_Occurred()) SWIG_fail;
28388 }
28389 {
28390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28391 }
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28399 PyObject *resultobj;
28400 wxWindow *arg1 = (wxWindow *) 0 ;
28401 int arg2 ;
28402 bool result;
28403 PyObject * obj0 = 0 ;
28404 PyObject * obj1 = 0 ;
28405 char *kwnames[] = {
28406 (char *) "self",(char *) "hotkeyId", NULL
28407 };
28408
28409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28411 if (SWIG_arg_fail(1)) SWIG_fail;
28412 {
28413 arg2 = (int)(SWIG_As_int(obj1));
28414 if (SWIG_arg_fail(2)) SWIG_fail;
28415 }
28416 {
28417 PyThreadState* __tstate = wxPyBeginAllowThreads();
28418 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28419
28420 wxPyEndAllowThreads(__tstate);
28421 if (PyErr_Occurred()) SWIG_fail;
28422 }
28423 {
28424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28425 }
28426 return resultobj;
28427 fail:
28428 return NULL;
28429 }
28430
28431
28432 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28433 PyObject *resultobj;
28434 wxWindow *arg1 = (wxWindow *) 0 ;
28435 wxPoint *arg2 = 0 ;
28436 wxPoint result;
28437 wxPoint temp2 ;
28438 PyObject * obj0 = 0 ;
28439 PyObject * obj1 = 0 ;
28440 char *kwnames[] = {
28441 (char *) "self",(char *) "pt", NULL
28442 };
28443
28444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28446 if (SWIG_arg_fail(1)) SWIG_fail;
28447 {
28448 arg2 = &temp2;
28449 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28450 }
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28454
28455 wxPyEndAllowThreads(__tstate);
28456 if (PyErr_Occurred()) SWIG_fail;
28457 }
28458 {
28459 wxPoint * resultptr;
28460 resultptr = new wxPoint((wxPoint &)(result));
28461 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28462 }
28463 return resultobj;
28464 fail:
28465 return NULL;
28466 }
28467
28468
28469 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28470 PyObject *resultobj;
28471 wxWindow *arg1 = (wxWindow *) 0 ;
28472 wxSize *arg2 = 0 ;
28473 wxSize result;
28474 wxSize temp2 ;
28475 PyObject * obj0 = 0 ;
28476 PyObject * obj1 = 0 ;
28477 char *kwnames[] = {
28478 (char *) "self",(char *) "sz", NULL
28479 };
28480
28481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28483 if (SWIG_arg_fail(1)) SWIG_fail;
28484 {
28485 arg2 = &temp2;
28486 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28487 }
28488 {
28489 PyThreadState* __tstate = wxPyBeginAllowThreads();
28490 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28491
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 wxSize * resultptr;
28497 resultptr = new wxSize((wxSize &)(result));
28498 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28499 }
28500 return resultobj;
28501 fail:
28502 return NULL;
28503 }
28504
28505
28506 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28507 PyObject *resultobj;
28508 wxWindow *arg1 = (wxWindow *) 0 ;
28509 wxPoint *arg2 = 0 ;
28510 wxPoint result;
28511 wxPoint temp2 ;
28512 PyObject * obj0 = 0 ;
28513 PyObject * obj1 = 0 ;
28514 char *kwnames[] = {
28515 (char *) "self",(char *) "pt", NULL
28516 };
28517
28518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28520 if (SWIG_arg_fail(1)) SWIG_fail;
28521 {
28522 arg2 = &temp2;
28523 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28524 }
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28528
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 {
28533 wxPoint * resultptr;
28534 resultptr = new wxPoint((wxPoint &)(result));
28535 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28536 }
28537 return resultobj;
28538 fail:
28539 return NULL;
28540 }
28541
28542
28543 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28544 PyObject *resultobj;
28545 wxWindow *arg1 = (wxWindow *) 0 ;
28546 wxSize *arg2 = 0 ;
28547 wxSize result;
28548 wxSize temp2 ;
28549 PyObject * obj0 = 0 ;
28550 PyObject * obj1 = 0 ;
28551 char *kwnames[] = {
28552 (char *) "self",(char *) "sz", NULL
28553 };
28554
28555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28557 if (SWIG_arg_fail(1)) SWIG_fail;
28558 {
28559 arg2 = &temp2;
28560 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28561 }
28562 {
28563 PyThreadState* __tstate = wxPyBeginAllowThreads();
28564 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28565
28566 wxPyEndAllowThreads(__tstate);
28567 if (PyErr_Occurred()) SWIG_fail;
28568 }
28569 {
28570 wxSize * resultptr;
28571 resultptr = new wxSize((wxSize &)(result));
28572 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28573 }
28574 return resultobj;
28575 fail:
28576 return NULL;
28577 }
28578
28579
28580 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28581 PyObject *resultobj;
28582 wxWindow *arg1 = (wxWindow *) 0 ;
28583 wxPoint *arg2 = 0 ;
28584 wxPoint result;
28585 wxPoint temp2 ;
28586 PyObject * obj0 = 0 ;
28587 PyObject * obj1 = 0 ;
28588 char *kwnames[] = {
28589 (char *) "self",(char *) "pt", NULL
28590 };
28591
28592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28594 if (SWIG_arg_fail(1)) SWIG_fail;
28595 {
28596 arg2 = &temp2;
28597 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28598 }
28599 {
28600 PyThreadState* __tstate = wxPyBeginAllowThreads();
28601 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28602
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 {
28607 wxPoint * resultptr;
28608 resultptr = new wxPoint((wxPoint &)(result));
28609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28610 }
28611 return resultobj;
28612 fail:
28613 return NULL;
28614 }
28615
28616
28617 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28618 PyObject *resultobj;
28619 wxWindow *arg1 = (wxWindow *) 0 ;
28620 wxSize *arg2 = 0 ;
28621 wxSize result;
28622 wxSize temp2 ;
28623 PyObject * obj0 = 0 ;
28624 PyObject * obj1 = 0 ;
28625 char *kwnames[] = {
28626 (char *) "self",(char *) "sz", NULL
28627 };
28628
28629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28631 if (SWIG_arg_fail(1)) SWIG_fail;
28632 {
28633 arg2 = &temp2;
28634 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28635 }
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28639
28640 wxPyEndAllowThreads(__tstate);
28641 if (PyErr_Occurred()) SWIG_fail;
28642 }
28643 {
28644 wxSize * resultptr;
28645 resultptr = new wxSize((wxSize &)(result));
28646 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28647 }
28648 return resultobj;
28649 fail:
28650 return NULL;
28651 }
28652
28653
28654 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28655 PyObject *resultobj;
28656 wxWindow *arg1 = (wxWindow *) 0 ;
28657 int arg2 ;
28658 int arg3 ;
28659 PyObject * obj0 = 0 ;
28660 PyObject * obj1 = 0 ;
28661 PyObject * obj2 = 0 ;
28662 char *kwnames[] = {
28663 (char *) "self",(char *) "x",(char *) "y", NULL
28664 };
28665
28666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28668 if (SWIG_arg_fail(1)) SWIG_fail;
28669 {
28670 arg2 = (int)(SWIG_As_int(obj1));
28671 if (SWIG_arg_fail(2)) SWIG_fail;
28672 }
28673 {
28674 arg3 = (int)(SWIG_As_int(obj2));
28675 if (SWIG_arg_fail(3)) SWIG_fail;
28676 }
28677 {
28678 PyThreadState* __tstate = wxPyBeginAllowThreads();
28679 (arg1)->WarpPointer(arg2,arg3);
28680
28681 wxPyEndAllowThreads(__tstate);
28682 if (PyErr_Occurred()) SWIG_fail;
28683 }
28684 Py_INCREF(Py_None); resultobj = Py_None;
28685 return resultobj;
28686 fail:
28687 return NULL;
28688 }
28689
28690
28691 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28692 PyObject *resultobj;
28693 wxWindow *arg1 = (wxWindow *) 0 ;
28694 PyObject * obj0 = 0 ;
28695 char *kwnames[] = {
28696 (char *) "self", NULL
28697 };
28698
28699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28701 if (SWIG_arg_fail(1)) SWIG_fail;
28702 {
28703 PyThreadState* __tstate = wxPyBeginAllowThreads();
28704 (arg1)->CaptureMouse();
28705
28706 wxPyEndAllowThreads(__tstate);
28707 if (PyErr_Occurred()) SWIG_fail;
28708 }
28709 Py_INCREF(Py_None); resultobj = Py_None;
28710 return resultobj;
28711 fail:
28712 return NULL;
28713 }
28714
28715
28716 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28717 PyObject *resultobj;
28718 wxWindow *arg1 = (wxWindow *) 0 ;
28719 PyObject * obj0 = 0 ;
28720 char *kwnames[] = {
28721 (char *) "self", NULL
28722 };
28723
28724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28726 if (SWIG_arg_fail(1)) SWIG_fail;
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 (arg1)->ReleaseMouse();
28730
28731 wxPyEndAllowThreads(__tstate);
28732 if (PyErr_Occurred()) SWIG_fail;
28733 }
28734 Py_INCREF(Py_None); resultobj = Py_None;
28735 return resultobj;
28736 fail:
28737 return NULL;
28738 }
28739
28740
28741 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28742 PyObject *resultobj;
28743 wxWindow *result;
28744 char *kwnames[] = {
28745 NULL
28746 };
28747
28748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28749 {
28750 if (!wxPyCheckForApp()) SWIG_fail;
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 result = (wxWindow *)wxWindow::GetCapture();
28753
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 {
28758 resultobj = wxPyMake_wxObject(result, 0);
28759 }
28760 return resultobj;
28761 fail:
28762 return NULL;
28763 }
28764
28765
28766 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28767 PyObject *resultobj;
28768 wxWindow *arg1 = (wxWindow *) 0 ;
28769 bool result;
28770 PyObject * obj0 = 0 ;
28771 char *kwnames[] = {
28772 (char *) "self", NULL
28773 };
28774
28775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28777 if (SWIG_arg_fail(1)) SWIG_fail;
28778 {
28779 PyThreadState* __tstate = wxPyBeginAllowThreads();
28780 result = (bool)((wxWindow const *)arg1)->HasCapture();
28781
28782 wxPyEndAllowThreads(__tstate);
28783 if (PyErr_Occurred()) SWIG_fail;
28784 }
28785 {
28786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28787 }
28788 return resultobj;
28789 fail:
28790 return NULL;
28791 }
28792
28793
28794 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28795 PyObject *resultobj;
28796 wxWindow *arg1 = (wxWindow *) 0 ;
28797 bool arg2 = (bool) true ;
28798 wxRect *arg3 = (wxRect *) NULL ;
28799 PyObject * obj0 = 0 ;
28800 PyObject * obj1 = 0 ;
28801 PyObject * obj2 = 0 ;
28802 char *kwnames[] = {
28803 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28804 };
28805
28806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28808 if (SWIG_arg_fail(1)) SWIG_fail;
28809 if (obj1) {
28810 {
28811 arg2 = (bool)(SWIG_As_bool(obj1));
28812 if (SWIG_arg_fail(2)) SWIG_fail;
28813 }
28814 }
28815 if (obj2) {
28816 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28817 if (SWIG_arg_fail(3)) SWIG_fail;
28818 }
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28822
28823 wxPyEndAllowThreads(__tstate);
28824 if (PyErr_Occurred()) SWIG_fail;
28825 }
28826 Py_INCREF(Py_None); resultobj = Py_None;
28827 return resultobj;
28828 fail:
28829 return NULL;
28830 }
28831
28832
28833 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28834 PyObject *resultobj;
28835 wxWindow *arg1 = (wxWindow *) 0 ;
28836 wxRect *arg2 = 0 ;
28837 bool arg3 = (bool) true ;
28838 wxRect temp2 ;
28839 PyObject * obj0 = 0 ;
28840 PyObject * obj1 = 0 ;
28841 PyObject * obj2 = 0 ;
28842 char *kwnames[] = {
28843 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28844 };
28845
28846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28848 if (SWIG_arg_fail(1)) SWIG_fail;
28849 {
28850 arg2 = &temp2;
28851 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28852 }
28853 if (obj2) {
28854 {
28855 arg3 = (bool)(SWIG_As_bool(obj2));
28856 if (SWIG_arg_fail(3)) SWIG_fail;
28857 }
28858 }
28859 {
28860 PyThreadState* __tstate = wxPyBeginAllowThreads();
28861 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28862
28863 wxPyEndAllowThreads(__tstate);
28864 if (PyErr_Occurred()) SWIG_fail;
28865 }
28866 Py_INCREF(Py_None); resultobj = Py_None;
28867 return resultobj;
28868 fail:
28869 return NULL;
28870 }
28871
28872
28873 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28874 PyObject *resultobj;
28875 wxWindow *arg1 = (wxWindow *) 0 ;
28876 PyObject * obj0 = 0 ;
28877 char *kwnames[] = {
28878 (char *) "self", NULL
28879 };
28880
28881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28883 if (SWIG_arg_fail(1)) SWIG_fail;
28884 {
28885 PyThreadState* __tstate = wxPyBeginAllowThreads();
28886 (arg1)->Update();
28887
28888 wxPyEndAllowThreads(__tstate);
28889 if (PyErr_Occurred()) SWIG_fail;
28890 }
28891 Py_INCREF(Py_None); resultobj = Py_None;
28892 return resultobj;
28893 fail:
28894 return NULL;
28895 }
28896
28897
28898 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28899 PyObject *resultobj;
28900 wxWindow *arg1 = (wxWindow *) 0 ;
28901 PyObject * obj0 = 0 ;
28902 char *kwnames[] = {
28903 (char *) "self", NULL
28904 };
28905
28906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28908 if (SWIG_arg_fail(1)) SWIG_fail;
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 (arg1)->ClearBackground();
28912
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 Py_INCREF(Py_None); resultobj = Py_None;
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28924 PyObject *resultobj;
28925 wxWindow *arg1 = (wxWindow *) 0 ;
28926 PyObject * obj0 = 0 ;
28927 char *kwnames[] = {
28928 (char *) "self", NULL
28929 };
28930
28931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28933 if (SWIG_arg_fail(1)) SWIG_fail;
28934 {
28935 PyThreadState* __tstate = wxPyBeginAllowThreads();
28936 (arg1)->Freeze();
28937
28938 wxPyEndAllowThreads(__tstate);
28939 if (PyErr_Occurred()) SWIG_fail;
28940 }
28941 Py_INCREF(Py_None); resultobj = Py_None;
28942 return resultobj;
28943 fail:
28944 return NULL;
28945 }
28946
28947
28948 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28949 PyObject *resultobj;
28950 wxWindow *arg1 = (wxWindow *) 0 ;
28951 PyObject * obj0 = 0 ;
28952 char *kwnames[] = {
28953 (char *) "self", NULL
28954 };
28955
28956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28958 if (SWIG_arg_fail(1)) SWIG_fail;
28959 {
28960 PyThreadState* __tstate = wxPyBeginAllowThreads();
28961 (arg1)->Thaw();
28962
28963 wxPyEndAllowThreads(__tstate);
28964 if (PyErr_Occurred()) SWIG_fail;
28965 }
28966 Py_INCREF(Py_None); resultobj = Py_None;
28967 return resultobj;
28968 fail:
28969 return NULL;
28970 }
28971
28972
28973 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28974 PyObject *resultobj;
28975 wxWindow *arg1 = (wxWindow *) 0 ;
28976 wxDC *arg2 = 0 ;
28977 PyObject * obj0 = 0 ;
28978 PyObject * obj1 = 0 ;
28979 char *kwnames[] = {
28980 (char *) "self",(char *) "dc", NULL
28981 };
28982
28983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28985 if (SWIG_arg_fail(1)) SWIG_fail;
28986 {
28987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28988 if (SWIG_arg_fail(2)) SWIG_fail;
28989 if (arg2 == NULL) {
28990 SWIG_null_ref("wxDC");
28991 }
28992 if (SWIG_arg_fail(2)) SWIG_fail;
28993 }
28994 {
28995 PyThreadState* __tstate = wxPyBeginAllowThreads();
28996 (arg1)->PrepareDC(*arg2);
28997
28998 wxPyEndAllowThreads(__tstate);
28999 if (PyErr_Occurred()) SWIG_fail;
29000 }
29001 Py_INCREF(Py_None); resultobj = Py_None;
29002 return resultobj;
29003 fail:
29004 return NULL;
29005 }
29006
29007
29008 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29009 PyObject *resultobj;
29010 wxWindow *arg1 = (wxWindow *) 0 ;
29011 wxRegion *result;
29012 PyObject * obj0 = 0 ;
29013 char *kwnames[] = {
29014 (char *) "self", NULL
29015 };
29016
29017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29019 if (SWIG_arg_fail(1)) SWIG_fail;
29020 {
29021 PyThreadState* __tstate = wxPyBeginAllowThreads();
29022 {
29023 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29024 result = (wxRegion *) &_result_ref;
29025 }
29026
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29038 PyObject *resultobj;
29039 wxWindow *arg1 = (wxWindow *) 0 ;
29040 wxRect result;
29041 PyObject * obj0 = 0 ;
29042 char *kwnames[] = {
29043 (char *) "self", NULL
29044 };
29045
29046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29048 if (SWIG_arg_fail(1)) SWIG_fail;
29049 {
29050 PyThreadState* __tstate = wxPyBeginAllowThreads();
29051 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29052
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 {
29057 wxRect * resultptr;
29058 resultptr = new wxRect((wxRect &)(result));
29059 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29060 }
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29068 PyObject *resultobj;
29069 wxWindow *arg1 = (wxWindow *) 0 ;
29070 int arg2 ;
29071 int arg3 ;
29072 int arg4 = (int) 1 ;
29073 int arg5 = (int) 1 ;
29074 bool result;
29075 PyObject * obj0 = 0 ;
29076 PyObject * obj1 = 0 ;
29077 PyObject * obj2 = 0 ;
29078 PyObject * obj3 = 0 ;
29079 PyObject * obj4 = 0 ;
29080 char *kwnames[] = {
29081 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29082 };
29083
29084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29086 if (SWIG_arg_fail(1)) SWIG_fail;
29087 {
29088 arg2 = (int)(SWIG_As_int(obj1));
29089 if (SWIG_arg_fail(2)) SWIG_fail;
29090 }
29091 {
29092 arg3 = (int)(SWIG_As_int(obj2));
29093 if (SWIG_arg_fail(3)) SWIG_fail;
29094 }
29095 if (obj3) {
29096 {
29097 arg4 = (int)(SWIG_As_int(obj3));
29098 if (SWIG_arg_fail(4)) SWIG_fail;
29099 }
29100 }
29101 if (obj4) {
29102 {
29103 arg5 = (int)(SWIG_As_int(obj4));
29104 if (SWIG_arg_fail(5)) SWIG_fail;
29105 }
29106 }
29107 {
29108 PyThreadState* __tstate = wxPyBeginAllowThreads();
29109 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29110
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 {
29115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29116 }
29117 return resultobj;
29118 fail:
29119 return NULL;
29120 }
29121
29122
29123 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29124 PyObject *resultobj;
29125 wxWindow *arg1 = (wxWindow *) 0 ;
29126 wxPoint *arg2 = 0 ;
29127 bool result;
29128 wxPoint temp2 ;
29129 PyObject * obj0 = 0 ;
29130 PyObject * obj1 = 0 ;
29131 char *kwnames[] = {
29132 (char *) "self",(char *) "pt", NULL
29133 };
29134
29135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29137 if (SWIG_arg_fail(1)) SWIG_fail;
29138 {
29139 arg2 = &temp2;
29140 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29141 }
29142 {
29143 PyThreadState* __tstate = wxPyBeginAllowThreads();
29144 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29145
29146 wxPyEndAllowThreads(__tstate);
29147 if (PyErr_Occurred()) SWIG_fail;
29148 }
29149 {
29150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29151 }
29152 return resultobj;
29153 fail:
29154 return NULL;
29155 }
29156
29157
29158 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29159 PyObject *resultobj;
29160 wxWindow *arg1 = (wxWindow *) 0 ;
29161 wxRect *arg2 = 0 ;
29162 bool result;
29163 wxRect temp2 ;
29164 PyObject * obj0 = 0 ;
29165 PyObject * obj1 = 0 ;
29166 char *kwnames[] = {
29167 (char *) "self",(char *) "rect", NULL
29168 };
29169
29170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29172 if (SWIG_arg_fail(1)) SWIG_fail;
29173 {
29174 arg2 = &temp2;
29175 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29176 }
29177 {
29178 PyThreadState* __tstate = wxPyBeginAllowThreads();
29179 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29180
29181 wxPyEndAllowThreads(__tstate);
29182 if (PyErr_Occurred()) SWIG_fail;
29183 }
29184 {
29185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29186 }
29187 return resultobj;
29188 fail:
29189 return NULL;
29190 }
29191
29192
29193 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29194 PyObject *resultobj;
29195 wxWindow *arg1 = (wxWindow *) 0 ;
29196 wxVisualAttributes result;
29197 PyObject * obj0 = 0 ;
29198 char *kwnames[] = {
29199 (char *) "self", NULL
29200 };
29201
29202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29204 if (SWIG_arg_fail(1)) SWIG_fail;
29205 {
29206 PyThreadState* __tstate = wxPyBeginAllowThreads();
29207 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29208
29209 wxPyEndAllowThreads(__tstate);
29210 if (PyErr_Occurred()) SWIG_fail;
29211 }
29212 {
29213 wxVisualAttributes * resultptr;
29214 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29215 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29216 }
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29224 PyObject *resultobj;
29225 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29226 wxVisualAttributes result;
29227 PyObject * obj0 = 0 ;
29228 char *kwnames[] = {
29229 (char *) "variant", NULL
29230 };
29231
29232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29233 if (obj0) {
29234 {
29235 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29236 if (SWIG_arg_fail(1)) SWIG_fail;
29237 }
29238 }
29239 {
29240 if (!wxPyCheckForApp()) SWIG_fail;
29241 PyThreadState* __tstate = wxPyBeginAllowThreads();
29242 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29243
29244 wxPyEndAllowThreads(__tstate);
29245 if (PyErr_Occurred()) SWIG_fail;
29246 }
29247 {
29248 wxVisualAttributes * resultptr;
29249 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29250 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29251 }
29252 return resultobj;
29253 fail:
29254 return NULL;
29255 }
29256
29257
29258 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29259 PyObject *resultobj;
29260 wxWindow *arg1 = (wxWindow *) 0 ;
29261 wxColour *arg2 = 0 ;
29262 bool result;
29263 wxColour temp2 ;
29264 PyObject * obj0 = 0 ;
29265 PyObject * obj1 = 0 ;
29266 char *kwnames[] = {
29267 (char *) "self",(char *) "colour", NULL
29268 };
29269
29270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29272 if (SWIG_arg_fail(1)) SWIG_fail;
29273 {
29274 arg2 = &temp2;
29275 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29276 }
29277 {
29278 PyThreadState* __tstate = wxPyBeginAllowThreads();
29279 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29280
29281 wxPyEndAllowThreads(__tstate);
29282 if (PyErr_Occurred()) SWIG_fail;
29283 }
29284 {
29285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29286 }
29287 return resultobj;
29288 fail:
29289 return NULL;
29290 }
29291
29292
29293 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29294 PyObject *resultobj;
29295 wxWindow *arg1 = (wxWindow *) 0 ;
29296 wxColour *arg2 = 0 ;
29297 wxColour temp2 ;
29298 PyObject * obj0 = 0 ;
29299 PyObject * obj1 = 0 ;
29300 char *kwnames[] = {
29301 (char *) "self",(char *) "colour", NULL
29302 };
29303
29304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29306 if (SWIG_arg_fail(1)) SWIG_fail;
29307 {
29308 arg2 = &temp2;
29309 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29310 }
29311 {
29312 PyThreadState* __tstate = wxPyBeginAllowThreads();
29313 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29314
29315 wxPyEndAllowThreads(__tstate);
29316 if (PyErr_Occurred()) SWIG_fail;
29317 }
29318 Py_INCREF(Py_None); resultobj = Py_None;
29319 return resultobj;
29320 fail:
29321 return NULL;
29322 }
29323
29324
29325 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29326 PyObject *resultobj;
29327 wxWindow *arg1 = (wxWindow *) 0 ;
29328 wxColour *arg2 = 0 ;
29329 bool result;
29330 wxColour temp2 ;
29331 PyObject * obj0 = 0 ;
29332 PyObject * obj1 = 0 ;
29333 char *kwnames[] = {
29334 (char *) "self",(char *) "colour", NULL
29335 };
29336
29337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29339 if (SWIG_arg_fail(1)) SWIG_fail;
29340 {
29341 arg2 = &temp2;
29342 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29343 }
29344 {
29345 PyThreadState* __tstate = wxPyBeginAllowThreads();
29346 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29347
29348 wxPyEndAllowThreads(__tstate);
29349 if (PyErr_Occurred()) SWIG_fail;
29350 }
29351 {
29352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29353 }
29354 return resultobj;
29355 fail:
29356 return NULL;
29357 }
29358
29359
29360 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29361 PyObject *resultobj;
29362 wxWindow *arg1 = (wxWindow *) 0 ;
29363 wxColour *arg2 = 0 ;
29364 wxColour temp2 ;
29365 PyObject * obj0 = 0 ;
29366 PyObject * obj1 = 0 ;
29367 char *kwnames[] = {
29368 (char *) "self",(char *) "colour", NULL
29369 };
29370
29371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29373 if (SWIG_arg_fail(1)) SWIG_fail;
29374 {
29375 arg2 = &temp2;
29376 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29377 }
29378 {
29379 PyThreadState* __tstate = wxPyBeginAllowThreads();
29380 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29381
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 Py_INCREF(Py_None); resultobj = Py_None;
29386 return resultobj;
29387 fail:
29388 return NULL;
29389 }
29390
29391
29392 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29393 PyObject *resultobj;
29394 wxWindow *arg1 = (wxWindow *) 0 ;
29395 wxColour result;
29396 PyObject * obj0 = 0 ;
29397 char *kwnames[] = {
29398 (char *) "self", NULL
29399 };
29400
29401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29403 if (SWIG_arg_fail(1)) SWIG_fail;
29404 {
29405 PyThreadState* __tstate = wxPyBeginAllowThreads();
29406 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29407
29408 wxPyEndAllowThreads(__tstate);
29409 if (PyErr_Occurred()) SWIG_fail;
29410 }
29411 {
29412 wxColour * resultptr;
29413 resultptr = new wxColour((wxColour &)(result));
29414 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29415 }
29416 return resultobj;
29417 fail:
29418 return NULL;
29419 }
29420
29421
29422 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29423 PyObject *resultobj;
29424 wxWindow *arg1 = (wxWindow *) 0 ;
29425 wxColour result;
29426 PyObject * obj0 = 0 ;
29427 char *kwnames[] = {
29428 (char *) "self", NULL
29429 };
29430
29431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29433 if (SWIG_arg_fail(1)) SWIG_fail;
29434 {
29435 PyThreadState* __tstate = wxPyBeginAllowThreads();
29436 result = ((wxWindow const *)arg1)->GetForegroundColour();
29437
29438 wxPyEndAllowThreads(__tstate);
29439 if (PyErr_Occurred()) SWIG_fail;
29440 }
29441 {
29442 wxColour * resultptr;
29443 resultptr = new wxColour((wxColour &)(result));
29444 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29445 }
29446 return resultobj;
29447 fail:
29448 return NULL;
29449 }
29450
29451
29452 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29453 PyObject *resultobj;
29454 wxWindow *arg1 = (wxWindow *) 0 ;
29455 wxBackgroundStyle arg2 ;
29456 bool result;
29457 PyObject * obj0 = 0 ;
29458 PyObject * obj1 = 0 ;
29459 char *kwnames[] = {
29460 (char *) "self",(char *) "style", NULL
29461 };
29462
29463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29465 if (SWIG_arg_fail(1)) SWIG_fail;
29466 {
29467 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29468 if (SWIG_arg_fail(2)) SWIG_fail;
29469 }
29470 {
29471 PyThreadState* __tstate = wxPyBeginAllowThreads();
29472 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29473
29474 wxPyEndAllowThreads(__tstate);
29475 if (PyErr_Occurred()) SWIG_fail;
29476 }
29477 {
29478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29479 }
29480 return resultobj;
29481 fail:
29482 return NULL;
29483 }
29484
29485
29486 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29487 PyObject *resultobj;
29488 wxWindow *arg1 = (wxWindow *) 0 ;
29489 wxBackgroundStyle result;
29490 PyObject * obj0 = 0 ;
29491 char *kwnames[] = {
29492 (char *) "self", NULL
29493 };
29494
29495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29497 if (SWIG_arg_fail(1)) SWIG_fail;
29498 {
29499 PyThreadState* __tstate = wxPyBeginAllowThreads();
29500 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29501
29502 wxPyEndAllowThreads(__tstate);
29503 if (PyErr_Occurred()) SWIG_fail;
29504 }
29505 resultobj = SWIG_From_int((result));
29506 return resultobj;
29507 fail:
29508 return NULL;
29509 }
29510
29511
29512 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29513 PyObject *resultobj;
29514 wxWindow *arg1 = (wxWindow *) 0 ;
29515 bool result;
29516 PyObject * obj0 = 0 ;
29517 char *kwnames[] = {
29518 (char *) "self", NULL
29519 };
29520
29521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29523 if (SWIG_arg_fail(1)) SWIG_fail;
29524 {
29525 PyThreadState* __tstate = wxPyBeginAllowThreads();
29526 result = (bool)(arg1)->HasTransparentBackground();
29527
29528 wxPyEndAllowThreads(__tstate);
29529 if (PyErr_Occurred()) SWIG_fail;
29530 }
29531 {
29532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29533 }
29534 return resultobj;
29535 fail:
29536 return NULL;
29537 }
29538
29539
29540 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29541 PyObject *resultobj;
29542 wxWindow *arg1 = (wxWindow *) 0 ;
29543 wxCursor *arg2 = 0 ;
29544 bool result;
29545 PyObject * obj0 = 0 ;
29546 PyObject * obj1 = 0 ;
29547 char *kwnames[] = {
29548 (char *) "self",(char *) "cursor", NULL
29549 };
29550
29551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29553 if (SWIG_arg_fail(1)) SWIG_fail;
29554 {
29555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29556 if (SWIG_arg_fail(2)) SWIG_fail;
29557 if (arg2 == NULL) {
29558 SWIG_null_ref("wxCursor");
29559 }
29560 if (SWIG_arg_fail(2)) SWIG_fail;
29561 }
29562 {
29563 PyThreadState* __tstate = wxPyBeginAllowThreads();
29564 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29565
29566 wxPyEndAllowThreads(__tstate);
29567 if (PyErr_Occurred()) SWIG_fail;
29568 }
29569 {
29570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29571 }
29572 return resultobj;
29573 fail:
29574 return NULL;
29575 }
29576
29577
29578 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29579 PyObject *resultobj;
29580 wxWindow *arg1 = (wxWindow *) 0 ;
29581 wxCursor result;
29582 PyObject * obj0 = 0 ;
29583 char *kwnames[] = {
29584 (char *) "self", NULL
29585 };
29586
29587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29589 if (SWIG_arg_fail(1)) SWIG_fail;
29590 {
29591 PyThreadState* __tstate = wxPyBeginAllowThreads();
29592 result = (arg1)->GetCursor();
29593
29594 wxPyEndAllowThreads(__tstate);
29595 if (PyErr_Occurred()) SWIG_fail;
29596 }
29597 {
29598 wxCursor * resultptr;
29599 resultptr = new wxCursor((wxCursor &)(result));
29600 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29601 }
29602 return resultobj;
29603 fail:
29604 return NULL;
29605 }
29606
29607
29608 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29609 PyObject *resultobj;
29610 wxWindow *arg1 = (wxWindow *) 0 ;
29611 wxFont *arg2 = 0 ;
29612 bool result;
29613 PyObject * obj0 = 0 ;
29614 PyObject * obj1 = 0 ;
29615 char *kwnames[] = {
29616 (char *) "self",(char *) "font", NULL
29617 };
29618
29619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29621 if (SWIG_arg_fail(1)) SWIG_fail;
29622 {
29623 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29624 if (SWIG_arg_fail(2)) SWIG_fail;
29625 if (arg2 == NULL) {
29626 SWIG_null_ref("wxFont");
29627 }
29628 if (SWIG_arg_fail(2)) SWIG_fail;
29629 }
29630 {
29631 PyThreadState* __tstate = wxPyBeginAllowThreads();
29632 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29633
29634 wxPyEndAllowThreads(__tstate);
29635 if (PyErr_Occurred()) SWIG_fail;
29636 }
29637 {
29638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29639 }
29640 return resultobj;
29641 fail:
29642 return NULL;
29643 }
29644
29645
29646 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29647 PyObject *resultobj;
29648 wxWindow *arg1 = (wxWindow *) 0 ;
29649 wxFont *arg2 = 0 ;
29650 PyObject * obj0 = 0 ;
29651 PyObject * obj1 = 0 ;
29652 char *kwnames[] = {
29653 (char *) "self",(char *) "font", NULL
29654 };
29655
29656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29658 if (SWIG_arg_fail(1)) SWIG_fail;
29659 {
29660 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29661 if (SWIG_arg_fail(2)) SWIG_fail;
29662 if (arg2 == NULL) {
29663 SWIG_null_ref("wxFont");
29664 }
29665 if (SWIG_arg_fail(2)) SWIG_fail;
29666 }
29667 {
29668 PyThreadState* __tstate = wxPyBeginAllowThreads();
29669 (arg1)->SetOwnFont((wxFont const &)*arg2);
29670
29671 wxPyEndAllowThreads(__tstate);
29672 if (PyErr_Occurred()) SWIG_fail;
29673 }
29674 Py_INCREF(Py_None); resultobj = Py_None;
29675 return resultobj;
29676 fail:
29677 return NULL;
29678 }
29679
29680
29681 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29682 PyObject *resultobj;
29683 wxWindow *arg1 = (wxWindow *) 0 ;
29684 wxFont result;
29685 PyObject * obj0 = 0 ;
29686 char *kwnames[] = {
29687 (char *) "self", NULL
29688 };
29689
29690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29692 if (SWIG_arg_fail(1)) SWIG_fail;
29693 {
29694 PyThreadState* __tstate = wxPyBeginAllowThreads();
29695 result = (arg1)->GetFont();
29696
29697 wxPyEndAllowThreads(__tstate);
29698 if (PyErr_Occurred()) SWIG_fail;
29699 }
29700 {
29701 wxFont * resultptr;
29702 resultptr = new wxFont((wxFont &)(result));
29703 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29704 }
29705 return resultobj;
29706 fail:
29707 return NULL;
29708 }
29709
29710
29711 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29712 PyObject *resultobj;
29713 wxWindow *arg1 = (wxWindow *) 0 ;
29714 wxCaret *arg2 = (wxCaret *) 0 ;
29715 PyObject * obj0 = 0 ;
29716 PyObject * obj1 = 0 ;
29717 char *kwnames[] = {
29718 (char *) "self",(char *) "caret", NULL
29719 };
29720
29721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29723 if (SWIG_arg_fail(1)) SWIG_fail;
29724 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29725 if (SWIG_arg_fail(2)) SWIG_fail;
29726 {
29727 PyThreadState* __tstate = wxPyBeginAllowThreads();
29728 (arg1)->SetCaret(arg2);
29729
29730 wxPyEndAllowThreads(__tstate);
29731 if (PyErr_Occurred()) SWIG_fail;
29732 }
29733 Py_INCREF(Py_None); resultobj = Py_None;
29734 return resultobj;
29735 fail:
29736 return NULL;
29737 }
29738
29739
29740 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29741 PyObject *resultobj;
29742 wxWindow *arg1 = (wxWindow *) 0 ;
29743 wxCaret *result;
29744 PyObject * obj0 = 0 ;
29745 char *kwnames[] = {
29746 (char *) "self", NULL
29747 };
29748
29749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29751 if (SWIG_arg_fail(1)) SWIG_fail;
29752 {
29753 PyThreadState* __tstate = wxPyBeginAllowThreads();
29754 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29755
29756 wxPyEndAllowThreads(__tstate);
29757 if (PyErr_Occurred()) SWIG_fail;
29758 }
29759 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29760 return resultobj;
29761 fail:
29762 return NULL;
29763 }
29764
29765
29766 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29767 PyObject *resultobj;
29768 wxWindow *arg1 = (wxWindow *) 0 ;
29769 int result;
29770 PyObject * obj0 = 0 ;
29771 char *kwnames[] = {
29772 (char *) "self", NULL
29773 };
29774
29775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29777 if (SWIG_arg_fail(1)) SWIG_fail;
29778 {
29779 PyThreadState* __tstate = wxPyBeginAllowThreads();
29780 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29781
29782 wxPyEndAllowThreads(__tstate);
29783 if (PyErr_Occurred()) SWIG_fail;
29784 }
29785 {
29786 resultobj = SWIG_From_int((int)(result));
29787 }
29788 return resultobj;
29789 fail:
29790 return NULL;
29791 }
29792
29793
29794 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29795 PyObject *resultobj;
29796 wxWindow *arg1 = (wxWindow *) 0 ;
29797 int result;
29798 PyObject * obj0 = 0 ;
29799 char *kwnames[] = {
29800 (char *) "self", NULL
29801 };
29802
29803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29805 if (SWIG_arg_fail(1)) SWIG_fail;
29806 {
29807 PyThreadState* __tstate = wxPyBeginAllowThreads();
29808 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29809
29810 wxPyEndAllowThreads(__tstate);
29811 if (PyErr_Occurred()) SWIG_fail;
29812 }
29813 {
29814 resultobj = SWIG_From_int((int)(result));
29815 }
29816 return resultobj;
29817 fail:
29818 return NULL;
29819 }
29820
29821
29822 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29823 PyObject *resultobj;
29824 wxWindow *arg1 = (wxWindow *) 0 ;
29825 wxString *arg2 = 0 ;
29826 int *arg3 = (int *) 0 ;
29827 int *arg4 = (int *) 0 ;
29828 bool temp2 = false ;
29829 int temp3 ;
29830 int res3 = 0 ;
29831 int temp4 ;
29832 int res4 = 0 ;
29833 PyObject * obj0 = 0 ;
29834 PyObject * obj1 = 0 ;
29835 char *kwnames[] = {
29836 (char *) "self",(char *) "string", NULL
29837 };
29838
29839 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29840 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29843 if (SWIG_arg_fail(1)) SWIG_fail;
29844 {
29845 arg2 = wxString_in_helper(obj1);
29846 if (arg2 == NULL) SWIG_fail;
29847 temp2 = true;
29848 }
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29852
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 Py_INCREF(Py_None); resultobj = Py_None;
29857 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29858 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29859 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29860 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29861 {
29862 if (temp2)
29863 delete arg2;
29864 }
29865 return resultobj;
29866 fail:
29867 {
29868 if (temp2)
29869 delete arg2;
29870 }
29871 return NULL;
29872 }
29873
29874
29875 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29876 PyObject *resultobj;
29877 wxWindow *arg1 = (wxWindow *) 0 ;
29878 wxString *arg2 = 0 ;
29879 int *arg3 = (int *) 0 ;
29880 int *arg4 = (int *) 0 ;
29881 int *arg5 = (int *) 0 ;
29882 int *arg6 = (int *) 0 ;
29883 wxFont *arg7 = (wxFont *) NULL ;
29884 bool temp2 = false ;
29885 int temp3 ;
29886 int res3 = 0 ;
29887 int temp4 ;
29888 int res4 = 0 ;
29889 int temp5 ;
29890 int res5 = 0 ;
29891 int temp6 ;
29892 int res6 = 0 ;
29893 PyObject * obj0 = 0 ;
29894 PyObject * obj1 = 0 ;
29895 PyObject * obj2 = 0 ;
29896 char *kwnames[] = {
29897 (char *) "self",(char *) "string",(char *) "font", NULL
29898 };
29899
29900 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29901 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29902 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29903 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29906 if (SWIG_arg_fail(1)) SWIG_fail;
29907 {
29908 arg2 = wxString_in_helper(obj1);
29909 if (arg2 == NULL) SWIG_fail;
29910 temp2 = true;
29911 }
29912 if (obj2) {
29913 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29914 if (SWIG_arg_fail(7)) SWIG_fail;
29915 }
29916 {
29917 PyThreadState* __tstate = wxPyBeginAllowThreads();
29918 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29919
29920 wxPyEndAllowThreads(__tstate);
29921 if (PyErr_Occurred()) SWIG_fail;
29922 }
29923 Py_INCREF(Py_None); resultobj = Py_None;
29924 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29925 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29926 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29927 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29928 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29929 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29930 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29931 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29932 {
29933 if (temp2)
29934 delete arg2;
29935 }
29936 return resultobj;
29937 fail:
29938 {
29939 if (temp2)
29940 delete arg2;
29941 }
29942 return NULL;
29943 }
29944
29945
29946 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29947 PyObject *resultobj;
29948 wxWindow *arg1 = (wxWindow *) 0 ;
29949 int *arg2 = (int *) 0 ;
29950 int *arg3 = (int *) 0 ;
29951 int temp2 ;
29952 int res2 = 0 ;
29953 int temp3 ;
29954 int res3 = 0 ;
29955 PyObject * obj0 = 0 ;
29956 PyObject * obj1 = 0 ;
29957 PyObject * obj2 = 0 ;
29958 char *kwnames[] = {
29959 (char *) "self",(char *) "x",(char *) "y", NULL
29960 };
29961
29962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29964 if (SWIG_arg_fail(1)) SWIG_fail;
29965 {
29966 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29967 temp2 = SWIG_As_int(obj1);
29968 if (SWIG_arg_fail(2)) SWIG_fail;
29969 arg2 = &temp2;
29970 res2 = SWIG_NEWOBJ;
29971 }
29972 }
29973 {
29974 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29975 temp3 = SWIG_As_int(obj2);
29976 if (SWIG_arg_fail(3)) SWIG_fail;
29977 arg3 = &temp3;
29978 res3 = SWIG_NEWOBJ;
29979 }
29980 }
29981 {
29982 PyThreadState* __tstate = wxPyBeginAllowThreads();
29983 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29984
29985 wxPyEndAllowThreads(__tstate);
29986 if (PyErr_Occurred()) SWIG_fail;
29987 }
29988 Py_INCREF(Py_None); resultobj = Py_None;
29989 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29990 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29991 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29992 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29993 return resultobj;
29994 fail:
29995 return NULL;
29996 }
29997
29998
29999 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30000 PyObject *resultobj;
30001 wxWindow *arg1 = (wxWindow *) 0 ;
30002 int *arg2 = (int *) 0 ;
30003 int *arg3 = (int *) 0 ;
30004 int temp2 ;
30005 int res2 = 0 ;
30006 int temp3 ;
30007 int res3 = 0 ;
30008 PyObject * obj0 = 0 ;
30009 PyObject * obj1 = 0 ;
30010 PyObject * obj2 = 0 ;
30011 char *kwnames[] = {
30012 (char *) "self",(char *) "x",(char *) "y", NULL
30013 };
30014
30015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30017 if (SWIG_arg_fail(1)) SWIG_fail;
30018 {
30019 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30020 temp2 = SWIG_As_int(obj1);
30021 if (SWIG_arg_fail(2)) SWIG_fail;
30022 arg2 = &temp2;
30023 res2 = SWIG_NEWOBJ;
30024 }
30025 }
30026 {
30027 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30028 temp3 = SWIG_As_int(obj2);
30029 if (SWIG_arg_fail(3)) SWIG_fail;
30030 arg3 = &temp3;
30031 res3 = SWIG_NEWOBJ;
30032 }
30033 }
30034 {
30035 PyThreadState* __tstate = wxPyBeginAllowThreads();
30036 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30037
30038 wxPyEndAllowThreads(__tstate);
30039 if (PyErr_Occurred()) SWIG_fail;
30040 }
30041 Py_INCREF(Py_None); resultobj = Py_None;
30042 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30043 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30044 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30045 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30046 return resultobj;
30047 fail:
30048 return NULL;
30049 }
30050
30051
30052 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30053 PyObject *resultobj;
30054 wxWindow *arg1 = (wxWindow *) 0 ;
30055 wxPoint *arg2 = 0 ;
30056 wxPoint result;
30057 wxPoint temp2 ;
30058 PyObject * obj0 = 0 ;
30059 PyObject * obj1 = 0 ;
30060 char *kwnames[] = {
30061 (char *) "self",(char *) "pt", NULL
30062 };
30063
30064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30066 if (SWIG_arg_fail(1)) SWIG_fail;
30067 {
30068 arg2 = &temp2;
30069 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30070 }
30071 {
30072 PyThreadState* __tstate = wxPyBeginAllowThreads();
30073 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30074
30075 wxPyEndAllowThreads(__tstate);
30076 if (PyErr_Occurred()) SWIG_fail;
30077 }
30078 {
30079 wxPoint * resultptr;
30080 resultptr = new wxPoint((wxPoint &)(result));
30081 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30082 }
30083 return resultobj;
30084 fail:
30085 return NULL;
30086 }
30087
30088
30089 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30090 PyObject *resultobj;
30091 wxWindow *arg1 = (wxWindow *) 0 ;
30092 wxPoint *arg2 = 0 ;
30093 wxPoint result;
30094 wxPoint temp2 ;
30095 PyObject * obj0 = 0 ;
30096 PyObject * obj1 = 0 ;
30097 char *kwnames[] = {
30098 (char *) "self",(char *) "pt", NULL
30099 };
30100
30101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30103 if (SWIG_arg_fail(1)) SWIG_fail;
30104 {
30105 arg2 = &temp2;
30106 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30107 }
30108 {
30109 PyThreadState* __tstate = wxPyBeginAllowThreads();
30110 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30111
30112 wxPyEndAllowThreads(__tstate);
30113 if (PyErr_Occurred()) SWIG_fail;
30114 }
30115 {
30116 wxPoint * resultptr;
30117 resultptr = new wxPoint((wxPoint &)(result));
30118 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30119 }
30120 return resultobj;
30121 fail:
30122 return NULL;
30123 }
30124
30125
30126 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30127 PyObject *resultobj;
30128 wxWindow *arg1 = (wxWindow *) 0 ;
30129 int arg2 ;
30130 int arg3 ;
30131 wxHitTest result;
30132 PyObject * obj0 = 0 ;
30133 PyObject * obj1 = 0 ;
30134 PyObject * obj2 = 0 ;
30135 char *kwnames[] = {
30136 (char *) "self",(char *) "x",(char *) "y", NULL
30137 };
30138
30139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30141 if (SWIG_arg_fail(1)) SWIG_fail;
30142 {
30143 arg2 = (int)(SWIG_As_int(obj1));
30144 if (SWIG_arg_fail(2)) SWIG_fail;
30145 }
30146 {
30147 arg3 = (int)(SWIG_As_int(obj2));
30148 if (SWIG_arg_fail(3)) SWIG_fail;
30149 }
30150 {
30151 PyThreadState* __tstate = wxPyBeginAllowThreads();
30152 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30153
30154 wxPyEndAllowThreads(__tstate);
30155 if (PyErr_Occurred()) SWIG_fail;
30156 }
30157 resultobj = SWIG_From_int((result));
30158 return resultobj;
30159 fail:
30160 return NULL;
30161 }
30162
30163
30164 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30165 PyObject *resultobj;
30166 wxWindow *arg1 = (wxWindow *) 0 ;
30167 wxPoint *arg2 = 0 ;
30168 wxHitTest result;
30169 wxPoint temp2 ;
30170 PyObject * obj0 = 0 ;
30171 PyObject * obj1 = 0 ;
30172 char *kwnames[] = {
30173 (char *) "self",(char *) "pt", NULL
30174 };
30175
30176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30178 if (SWIG_arg_fail(1)) SWIG_fail;
30179 {
30180 arg2 = &temp2;
30181 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30182 }
30183 {
30184 PyThreadState* __tstate = wxPyBeginAllowThreads();
30185 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30186
30187 wxPyEndAllowThreads(__tstate);
30188 if (PyErr_Occurred()) SWIG_fail;
30189 }
30190 resultobj = SWIG_From_int((result));
30191 return resultobj;
30192 fail:
30193 return NULL;
30194 }
30195
30196
30197 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30198 PyObject *resultobj;
30199 wxWindow *arg1 = (wxWindow *) 0 ;
30200 long arg2 ;
30201 wxBorder result;
30202 PyObject * obj0 = 0 ;
30203 PyObject * obj1 = 0 ;
30204
30205 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30207 if (SWIG_arg_fail(1)) SWIG_fail;
30208 {
30209 arg2 = (long)(SWIG_As_long(obj1));
30210 if (SWIG_arg_fail(2)) SWIG_fail;
30211 }
30212 {
30213 PyThreadState* __tstate = wxPyBeginAllowThreads();
30214 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30215
30216 wxPyEndAllowThreads(__tstate);
30217 if (PyErr_Occurred()) SWIG_fail;
30218 }
30219 resultobj = SWIG_From_int((result));
30220 return resultobj;
30221 fail:
30222 return NULL;
30223 }
30224
30225
30226 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30227 PyObject *resultobj;
30228 wxWindow *arg1 = (wxWindow *) 0 ;
30229 wxBorder result;
30230 PyObject * obj0 = 0 ;
30231
30232 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30234 if (SWIG_arg_fail(1)) SWIG_fail;
30235 {
30236 PyThreadState* __tstate = wxPyBeginAllowThreads();
30237 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30238
30239 wxPyEndAllowThreads(__tstate);
30240 if (PyErr_Occurred()) SWIG_fail;
30241 }
30242 resultobj = SWIG_From_int((result));
30243 return resultobj;
30244 fail:
30245 return NULL;
30246 }
30247
30248
30249 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30250 int argc;
30251 PyObject *argv[3];
30252 int ii;
30253
30254 argc = PyObject_Length(args);
30255 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30256 argv[ii] = PyTuple_GetItem(args,ii);
30257 }
30258 if (argc == 1) {
30259 int _v;
30260 {
30261 void *ptr;
30262 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30263 _v = 0;
30264 PyErr_Clear();
30265 } else {
30266 _v = 1;
30267 }
30268 }
30269 if (_v) {
30270 return _wrap_Window_GetBorder__SWIG_1(self,args);
30271 }
30272 }
30273 if (argc == 2) {
30274 int _v;
30275 {
30276 void *ptr;
30277 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30278 _v = 0;
30279 PyErr_Clear();
30280 } else {
30281 _v = 1;
30282 }
30283 }
30284 if (_v) {
30285 _v = SWIG_Check_long(argv[1]);
30286 if (_v) {
30287 return _wrap_Window_GetBorder__SWIG_0(self,args);
30288 }
30289 }
30290 }
30291
30292 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30293 return NULL;
30294 }
30295
30296
30297 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30298 PyObject *resultobj;
30299 wxWindow *arg1 = (wxWindow *) 0 ;
30300 long arg2 = (long) wxUPDATE_UI_NONE ;
30301 PyObject * obj0 = 0 ;
30302 PyObject * obj1 = 0 ;
30303 char *kwnames[] = {
30304 (char *) "self",(char *) "flags", NULL
30305 };
30306
30307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30309 if (SWIG_arg_fail(1)) SWIG_fail;
30310 if (obj1) {
30311 {
30312 arg2 = (long)(SWIG_As_long(obj1));
30313 if (SWIG_arg_fail(2)) SWIG_fail;
30314 }
30315 }
30316 {
30317 PyThreadState* __tstate = wxPyBeginAllowThreads();
30318 (arg1)->UpdateWindowUI(arg2);
30319
30320 wxPyEndAllowThreads(__tstate);
30321 if (PyErr_Occurred()) SWIG_fail;
30322 }
30323 Py_INCREF(Py_None); resultobj = Py_None;
30324 return resultobj;
30325 fail:
30326 return NULL;
30327 }
30328
30329
30330 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30331 PyObject *resultobj;
30332 wxWindow *arg1 = (wxWindow *) 0 ;
30333 wxMenu *arg2 = (wxMenu *) 0 ;
30334 int arg3 = (int) -1 ;
30335 int arg4 = (int) -1 ;
30336 bool result;
30337 PyObject * obj0 = 0 ;
30338 PyObject * obj1 = 0 ;
30339 PyObject * obj2 = 0 ;
30340 PyObject * obj3 = 0 ;
30341 char *kwnames[] = {
30342 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30343 };
30344
30345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30347 if (SWIG_arg_fail(1)) SWIG_fail;
30348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30349 if (SWIG_arg_fail(2)) SWIG_fail;
30350 if (obj2) {
30351 {
30352 arg3 = (int)(SWIG_As_int(obj2));
30353 if (SWIG_arg_fail(3)) SWIG_fail;
30354 }
30355 }
30356 if (obj3) {
30357 {
30358 arg4 = (int)(SWIG_As_int(obj3));
30359 if (SWIG_arg_fail(4)) SWIG_fail;
30360 }
30361 }
30362 {
30363 PyThreadState* __tstate = wxPyBeginAllowThreads();
30364 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30365
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 {
30370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30371 }
30372 return resultobj;
30373 fail:
30374 return NULL;
30375 }
30376
30377
30378 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30379 PyObject *resultobj;
30380 wxWindow *arg1 = (wxWindow *) 0 ;
30381 wxMenu *arg2 = (wxMenu *) 0 ;
30382 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30383 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30384 bool result;
30385 wxPoint temp3 ;
30386 PyObject * obj0 = 0 ;
30387 PyObject * obj1 = 0 ;
30388 PyObject * obj2 = 0 ;
30389 char *kwnames[] = {
30390 (char *) "self",(char *) "menu",(char *) "pos", NULL
30391 };
30392
30393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30395 if (SWIG_arg_fail(1)) SWIG_fail;
30396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30397 if (SWIG_arg_fail(2)) SWIG_fail;
30398 if (obj2) {
30399 {
30400 arg3 = &temp3;
30401 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30402 }
30403 }
30404 {
30405 PyThreadState* __tstate = wxPyBeginAllowThreads();
30406 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30407
30408 wxPyEndAllowThreads(__tstate);
30409 if (PyErr_Occurred()) SWIG_fail;
30410 }
30411 {
30412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30413 }
30414 return resultobj;
30415 fail:
30416 return NULL;
30417 }
30418
30419
30420 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30421 PyObject *resultobj;
30422 wxWindow *arg1 = (wxWindow *) 0 ;
30423 long result;
30424 PyObject * obj0 = 0 ;
30425 char *kwnames[] = {
30426 (char *) "self", NULL
30427 };
30428
30429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30431 if (SWIG_arg_fail(1)) SWIG_fail;
30432 {
30433 PyThreadState* __tstate = wxPyBeginAllowThreads();
30434 result = (long)wxWindow_GetHandle(arg1);
30435
30436 wxPyEndAllowThreads(__tstate);
30437 if (PyErr_Occurred()) SWIG_fail;
30438 }
30439 {
30440 resultobj = SWIG_From_long((long)(result));
30441 }
30442 return resultobj;
30443 fail:
30444 return NULL;
30445 }
30446
30447
30448 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30449 PyObject *resultobj;
30450 wxWindow *arg1 = (wxWindow *) 0 ;
30451 long arg2 ;
30452 PyObject * obj0 = 0 ;
30453 PyObject * obj1 = 0 ;
30454 char *kwnames[] = {
30455 (char *) "self",(char *) "handle", NULL
30456 };
30457
30458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30460 if (SWIG_arg_fail(1)) SWIG_fail;
30461 {
30462 arg2 = (long)(SWIG_As_long(obj1));
30463 if (SWIG_arg_fail(2)) SWIG_fail;
30464 }
30465 {
30466 PyThreadState* __tstate = wxPyBeginAllowThreads();
30467 wxWindow_AssociateHandle(arg1,arg2);
30468
30469 wxPyEndAllowThreads(__tstate);
30470 if (PyErr_Occurred()) SWIG_fail;
30471 }
30472 Py_INCREF(Py_None); resultobj = Py_None;
30473 return resultobj;
30474 fail:
30475 return NULL;
30476 }
30477
30478
30479 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30480 PyObject *resultobj;
30481 wxWindow *arg1 = (wxWindow *) 0 ;
30482 PyObject * obj0 = 0 ;
30483 char *kwnames[] = {
30484 (char *) "self", NULL
30485 };
30486
30487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30489 if (SWIG_arg_fail(1)) SWIG_fail;
30490 {
30491 PyThreadState* __tstate = wxPyBeginAllowThreads();
30492 (arg1)->DissociateHandle();
30493
30494 wxPyEndAllowThreads(__tstate);
30495 if (PyErr_Occurred()) SWIG_fail;
30496 }
30497 Py_INCREF(Py_None); resultobj = Py_None;
30498 return resultobj;
30499 fail:
30500 return NULL;
30501 }
30502
30503
30504 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30505 PyObject *resultobj;
30506 wxWindow *arg1 = (wxWindow *) 0 ;
30507 int arg2 ;
30508 bool result;
30509 PyObject * obj0 = 0 ;
30510 PyObject * obj1 = 0 ;
30511 char *kwnames[] = {
30512 (char *) "self",(char *) "orient", NULL
30513 };
30514
30515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30517 if (SWIG_arg_fail(1)) SWIG_fail;
30518 {
30519 arg2 = (int)(SWIG_As_int(obj1));
30520 if (SWIG_arg_fail(2)) SWIG_fail;
30521 }
30522 {
30523 PyThreadState* __tstate = wxPyBeginAllowThreads();
30524 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30525
30526 wxPyEndAllowThreads(__tstate);
30527 if (PyErr_Occurred()) SWIG_fail;
30528 }
30529 {
30530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30531 }
30532 return resultobj;
30533 fail:
30534 return NULL;
30535 }
30536
30537
30538 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30539 PyObject *resultobj;
30540 wxWindow *arg1 = (wxWindow *) 0 ;
30541 int arg2 ;
30542 int arg3 ;
30543 int arg4 ;
30544 int arg5 ;
30545 bool arg6 = (bool) true ;
30546 PyObject * obj0 = 0 ;
30547 PyObject * obj1 = 0 ;
30548 PyObject * obj2 = 0 ;
30549 PyObject * obj3 = 0 ;
30550 PyObject * obj4 = 0 ;
30551 PyObject * obj5 = 0 ;
30552 char *kwnames[] = {
30553 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30554 };
30555
30556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30558 if (SWIG_arg_fail(1)) SWIG_fail;
30559 {
30560 arg2 = (int)(SWIG_As_int(obj1));
30561 if (SWIG_arg_fail(2)) SWIG_fail;
30562 }
30563 {
30564 arg3 = (int)(SWIG_As_int(obj2));
30565 if (SWIG_arg_fail(3)) SWIG_fail;
30566 }
30567 {
30568 arg4 = (int)(SWIG_As_int(obj3));
30569 if (SWIG_arg_fail(4)) SWIG_fail;
30570 }
30571 {
30572 arg5 = (int)(SWIG_As_int(obj4));
30573 if (SWIG_arg_fail(5)) SWIG_fail;
30574 }
30575 if (obj5) {
30576 {
30577 arg6 = (bool)(SWIG_As_bool(obj5));
30578 if (SWIG_arg_fail(6)) SWIG_fail;
30579 }
30580 }
30581 {
30582 PyThreadState* __tstate = wxPyBeginAllowThreads();
30583 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30584
30585 wxPyEndAllowThreads(__tstate);
30586 if (PyErr_Occurred()) SWIG_fail;
30587 }
30588 Py_INCREF(Py_None); resultobj = Py_None;
30589 return resultobj;
30590 fail:
30591 return NULL;
30592 }
30593
30594
30595 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30596 PyObject *resultobj;
30597 wxWindow *arg1 = (wxWindow *) 0 ;
30598 int arg2 ;
30599 int arg3 ;
30600 bool arg4 = (bool) true ;
30601 PyObject * obj0 = 0 ;
30602 PyObject * obj1 = 0 ;
30603 PyObject * obj2 = 0 ;
30604 PyObject * obj3 = 0 ;
30605 char *kwnames[] = {
30606 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30607 };
30608
30609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30611 if (SWIG_arg_fail(1)) SWIG_fail;
30612 {
30613 arg2 = (int)(SWIG_As_int(obj1));
30614 if (SWIG_arg_fail(2)) SWIG_fail;
30615 }
30616 {
30617 arg3 = (int)(SWIG_As_int(obj2));
30618 if (SWIG_arg_fail(3)) SWIG_fail;
30619 }
30620 if (obj3) {
30621 {
30622 arg4 = (bool)(SWIG_As_bool(obj3));
30623 if (SWIG_arg_fail(4)) SWIG_fail;
30624 }
30625 }
30626 {
30627 PyThreadState* __tstate = wxPyBeginAllowThreads();
30628 (arg1)->SetScrollPos(arg2,arg3,arg4);
30629
30630 wxPyEndAllowThreads(__tstate);
30631 if (PyErr_Occurred()) SWIG_fail;
30632 }
30633 Py_INCREF(Py_None); resultobj = Py_None;
30634 return resultobj;
30635 fail:
30636 return NULL;
30637 }
30638
30639
30640 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30641 PyObject *resultobj;
30642 wxWindow *arg1 = (wxWindow *) 0 ;
30643 int arg2 ;
30644 int result;
30645 PyObject * obj0 = 0 ;
30646 PyObject * obj1 = 0 ;
30647 char *kwnames[] = {
30648 (char *) "self",(char *) "orientation", NULL
30649 };
30650
30651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30653 if (SWIG_arg_fail(1)) SWIG_fail;
30654 {
30655 arg2 = (int)(SWIG_As_int(obj1));
30656 if (SWIG_arg_fail(2)) SWIG_fail;
30657 }
30658 {
30659 PyThreadState* __tstate = wxPyBeginAllowThreads();
30660 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30661
30662 wxPyEndAllowThreads(__tstate);
30663 if (PyErr_Occurred()) SWIG_fail;
30664 }
30665 {
30666 resultobj = SWIG_From_int((int)(result));
30667 }
30668 return resultobj;
30669 fail:
30670 return NULL;
30671 }
30672
30673
30674 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30675 PyObject *resultobj;
30676 wxWindow *arg1 = (wxWindow *) 0 ;
30677 int arg2 ;
30678 int result;
30679 PyObject * obj0 = 0 ;
30680 PyObject * obj1 = 0 ;
30681 char *kwnames[] = {
30682 (char *) "self",(char *) "orientation", NULL
30683 };
30684
30685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30687 if (SWIG_arg_fail(1)) SWIG_fail;
30688 {
30689 arg2 = (int)(SWIG_As_int(obj1));
30690 if (SWIG_arg_fail(2)) SWIG_fail;
30691 }
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30695
30696 wxPyEndAllowThreads(__tstate);
30697 if (PyErr_Occurred()) SWIG_fail;
30698 }
30699 {
30700 resultobj = SWIG_From_int((int)(result));
30701 }
30702 return resultobj;
30703 fail:
30704 return NULL;
30705 }
30706
30707
30708 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30709 PyObject *resultobj;
30710 wxWindow *arg1 = (wxWindow *) 0 ;
30711 int arg2 ;
30712 int result;
30713 PyObject * obj0 = 0 ;
30714 PyObject * obj1 = 0 ;
30715 char *kwnames[] = {
30716 (char *) "self",(char *) "orientation", NULL
30717 };
30718
30719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30721 if (SWIG_arg_fail(1)) SWIG_fail;
30722 {
30723 arg2 = (int)(SWIG_As_int(obj1));
30724 if (SWIG_arg_fail(2)) SWIG_fail;
30725 }
30726 {
30727 PyThreadState* __tstate = wxPyBeginAllowThreads();
30728 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30729
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 {
30734 resultobj = SWIG_From_int((int)(result));
30735 }
30736 return resultobj;
30737 fail:
30738 return NULL;
30739 }
30740
30741
30742 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30743 PyObject *resultobj;
30744 wxWindow *arg1 = (wxWindow *) 0 ;
30745 int arg2 ;
30746 int arg3 ;
30747 wxRect *arg4 = (wxRect *) NULL ;
30748 PyObject * obj0 = 0 ;
30749 PyObject * obj1 = 0 ;
30750 PyObject * obj2 = 0 ;
30751 PyObject * obj3 = 0 ;
30752 char *kwnames[] = {
30753 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30754 };
30755
30756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30758 if (SWIG_arg_fail(1)) SWIG_fail;
30759 {
30760 arg2 = (int)(SWIG_As_int(obj1));
30761 if (SWIG_arg_fail(2)) SWIG_fail;
30762 }
30763 {
30764 arg3 = (int)(SWIG_As_int(obj2));
30765 if (SWIG_arg_fail(3)) SWIG_fail;
30766 }
30767 if (obj3) {
30768 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30769 if (SWIG_arg_fail(4)) SWIG_fail;
30770 }
30771 {
30772 PyThreadState* __tstate = wxPyBeginAllowThreads();
30773 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30774
30775 wxPyEndAllowThreads(__tstate);
30776 if (PyErr_Occurred()) SWIG_fail;
30777 }
30778 Py_INCREF(Py_None); resultobj = Py_None;
30779 return resultobj;
30780 fail:
30781 return NULL;
30782 }
30783
30784
30785 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30786 PyObject *resultobj;
30787 wxWindow *arg1 = (wxWindow *) 0 ;
30788 int arg2 ;
30789 bool result;
30790 PyObject * obj0 = 0 ;
30791 PyObject * obj1 = 0 ;
30792 char *kwnames[] = {
30793 (char *) "self",(char *) "lines", NULL
30794 };
30795
30796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30798 if (SWIG_arg_fail(1)) SWIG_fail;
30799 {
30800 arg2 = (int)(SWIG_As_int(obj1));
30801 if (SWIG_arg_fail(2)) SWIG_fail;
30802 }
30803 {
30804 PyThreadState* __tstate = wxPyBeginAllowThreads();
30805 result = (bool)(arg1)->ScrollLines(arg2);
30806
30807 wxPyEndAllowThreads(__tstate);
30808 if (PyErr_Occurred()) SWIG_fail;
30809 }
30810 {
30811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30812 }
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30820 PyObject *resultobj;
30821 wxWindow *arg1 = (wxWindow *) 0 ;
30822 int arg2 ;
30823 bool result;
30824 PyObject * obj0 = 0 ;
30825 PyObject * obj1 = 0 ;
30826 char *kwnames[] = {
30827 (char *) "self",(char *) "pages", NULL
30828 };
30829
30830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30832 if (SWIG_arg_fail(1)) SWIG_fail;
30833 {
30834 arg2 = (int)(SWIG_As_int(obj1));
30835 if (SWIG_arg_fail(2)) SWIG_fail;
30836 }
30837 {
30838 PyThreadState* __tstate = wxPyBeginAllowThreads();
30839 result = (bool)(arg1)->ScrollPages(arg2);
30840
30841 wxPyEndAllowThreads(__tstate);
30842 if (PyErr_Occurred()) SWIG_fail;
30843 }
30844 {
30845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30846 }
30847 return resultobj;
30848 fail:
30849 return NULL;
30850 }
30851
30852
30853 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30854 PyObject *resultobj;
30855 wxWindow *arg1 = (wxWindow *) 0 ;
30856 bool result;
30857 PyObject * obj0 = 0 ;
30858 char *kwnames[] = {
30859 (char *) "self", NULL
30860 };
30861
30862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30864 if (SWIG_arg_fail(1)) SWIG_fail;
30865 {
30866 PyThreadState* __tstate = wxPyBeginAllowThreads();
30867 result = (bool)(arg1)->LineUp();
30868
30869 wxPyEndAllowThreads(__tstate);
30870 if (PyErr_Occurred()) SWIG_fail;
30871 }
30872 {
30873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30874 }
30875 return resultobj;
30876 fail:
30877 return NULL;
30878 }
30879
30880
30881 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30882 PyObject *resultobj;
30883 wxWindow *arg1 = (wxWindow *) 0 ;
30884 bool result;
30885 PyObject * obj0 = 0 ;
30886 char *kwnames[] = {
30887 (char *) "self", NULL
30888 };
30889
30890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30892 if (SWIG_arg_fail(1)) SWIG_fail;
30893 {
30894 PyThreadState* __tstate = wxPyBeginAllowThreads();
30895 result = (bool)(arg1)->LineDown();
30896
30897 wxPyEndAllowThreads(__tstate);
30898 if (PyErr_Occurred()) SWIG_fail;
30899 }
30900 {
30901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30902 }
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30910 PyObject *resultobj;
30911 wxWindow *arg1 = (wxWindow *) 0 ;
30912 bool result;
30913 PyObject * obj0 = 0 ;
30914 char *kwnames[] = {
30915 (char *) "self", NULL
30916 };
30917
30918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30920 if (SWIG_arg_fail(1)) SWIG_fail;
30921 {
30922 PyThreadState* __tstate = wxPyBeginAllowThreads();
30923 result = (bool)(arg1)->PageUp();
30924
30925 wxPyEndAllowThreads(__tstate);
30926 if (PyErr_Occurred()) SWIG_fail;
30927 }
30928 {
30929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30930 }
30931 return resultobj;
30932 fail:
30933 return NULL;
30934 }
30935
30936
30937 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30938 PyObject *resultobj;
30939 wxWindow *arg1 = (wxWindow *) 0 ;
30940 bool result;
30941 PyObject * obj0 = 0 ;
30942 char *kwnames[] = {
30943 (char *) "self", NULL
30944 };
30945
30946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30948 if (SWIG_arg_fail(1)) SWIG_fail;
30949 {
30950 PyThreadState* __tstate = wxPyBeginAllowThreads();
30951 result = (bool)(arg1)->PageDown();
30952
30953 wxPyEndAllowThreads(__tstate);
30954 if (PyErr_Occurred()) SWIG_fail;
30955 }
30956 {
30957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30958 }
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30966 PyObject *resultobj;
30967 wxWindow *arg1 = (wxWindow *) 0 ;
30968 wxString *arg2 = 0 ;
30969 bool temp2 = false ;
30970 PyObject * obj0 = 0 ;
30971 PyObject * obj1 = 0 ;
30972 char *kwnames[] = {
30973 (char *) "self",(char *) "text", NULL
30974 };
30975
30976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30978 if (SWIG_arg_fail(1)) SWIG_fail;
30979 {
30980 arg2 = wxString_in_helper(obj1);
30981 if (arg2 == NULL) SWIG_fail;
30982 temp2 = true;
30983 }
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 (arg1)->SetHelpText((wxString const &)*arg2);
30987
30988 wxPyEndAllowThreads(__tstate);
30989 if (PyErr_Occurred()) SWIG_fail;
30990 }
30991 Py_INCREF(Py_None); resultobj = Py_None;
30992 {
30993 if (temp2)
30994 delete arg2;
30995 }
30996 return resultobj;
30997 fail:
30998 {
30999 if (temp2)
31000 delete arg2;
31001 }
31002 return NULL;
31003 }
31004
31005
31006 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31007 PyObject *resultobj;
31008 wxWindow *arg1 = (wxWindow *) 0 ;
31009 wxString *arg2 = 0 ;
31010 bool temp2 = false ;
31011 PyObject * obj0 = 0 ;
31012 PyObject * obj1 = 0 ;
31013 char *kwnames[] = {
31014 (char *) "self",(char *) "text", NULL
31015 };
31016
31017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31019 if (SWIG_arg_fail(1)) SWIG_fail;
31020 {
31021 arg2 = wxString_in_helper(obj1);
31022 if (arg2 == NULL) SWIG_fail;
31023 temp2 = true;
31024 }
31025 {
31026 PyThreadState* __tstate = wxPyBeginAllowThreads();
31027 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31028
31029 wxPyEndAllowThreads(__tstate);
31030 if (PyErr_Occurred()) SWIG_fail;
31031 }
31032 Py_INCREF(Py_None); resultobj = Py_None;
31033 {
31034 if (temp2)
31035 delete arg2;
31036 }
31037 return resultobj;
31038 fail:
31039 {
31040 if (temp2)
31041 delete arg2;
31042 }
31043 return NULL;
31044 }
31045
31046
31047 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31048 PyObject *resultobj;
31049 wxWindow *arg1 = (wxWindow *) 0 ;
31050 wxString result;
31051 PyObject * obj0 = 0 ;
31052 char *kwnames[] = {
31053 (char *) "self", NULL
31054 };
31055
31056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31058 if (SWIG_arg_fail(1)) SWIG_fail;
31059 {
31060 PyThreadState* __tstate = wxPyBeginAllowThreads();
31061 result = ((wxWindow const *)arg1)->GetHelpText();
31062
31063 wxPyEndAllowThreads(__tstate);
31064 if (PyErr_Occurred()) SWIG_fail;
31065 }
31066 {
31067 #if wxUSE_UNICODE
31068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31069 #else
31070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31071 #endif
31072 }
31073 return resultobj;
31074 fail:
31075 return NULL;
31076 }
31077
31078
31079 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31080 PyObject *resultobj;
31081 wxWindow *arg1 = (wxWindow *) 0 ;
31082 wxString *arg2 = 0 ;
31083 bool temp2 = false ;
31084 PyObject * obj0 = 0 ;
31085 PyObject * obj1 = 0 ;
31086 char *kwnames[] = {
31087 (char *) "self",(char *) "tip", NULL
31088 };
31089
31090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31092 if (SWIG_arg_fail(1)) SWIG_fail;
31093 {
31094 arg2 = wxString_in_helper(obj1);
31095 if (arg2 == NULL) SWIG_fail;
31096 temp2 = true;
31097 }
31098 {
31099 PyThreadState* __tstate = wxPyBeginAllowThreads();
31100 (arg1)->SetToolTip((wxString const &)*arg2);
31101
31102 wxPyEndAllowThreads(__tstate);
31103 if (PyErr_Occurred()) SWIG_fail;
31104 }
31105 Py_INCREF(Py_None); resultobj = Py_None;
31106 {
31107 if (temp2)
31108 delete arg2;
31109 }
31110 return resultobj;
31111 fail:
31112 {
31113 if (temp2)
31114 delete arg2;
31115 }
31116 return NULL;
31117 }
31118
31119
31120 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31121 PyObject *resultobj;
31122 wxWindow *arg1 = (wxWindow *) 0 ;
31123 wxToolTip *arg2 = (wxToolTip *) 0 ;
31124 PyObject * obj0 = 0 ;
31125 PyObject * obj1 = 0 ;
31126 char *kwnames[] = {
31127 (char *) "self",(char *) "tip", NULL
31128 };
31129
31130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31132 if (SWIG_arg_fail(1)) SWIG_fail;
31133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31134 if (SWIG_arg_fail(2)) SWIG_fail;
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 (arg1)->SetToolTip(arg2);
31138
31139 wxPyEndAllowThreads(__tstate);
31140 if (PyErr_Occurred()) SWIG_fail;
31141 }
31142 Py_INCREF(Py_None); resultobj = Py_None;
31143 return resultobj;
31144 fail:
31145 return NULL;
31146 }
31147
31148
31149 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31150 PyObject *resultobj;
31151 wxWindow *arg1 = (wxWindow *) 0 ;
31152 wxToolTip *result;
31153 PyObject * obj0 = 0 ;
31154 char *kwnames[] = {
31155 (char *) "self", NULL
31156 };
31157
31158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31160 if (SWIG_arg_fail(1)) SWIG_fail;
31161 {
31162 PyThreadState* __tstate = wxPyBeginAllowThreads();
31163 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31164
31165 wxPyEndAllowThreads(__tstate);
31166 if (PyErr_Occurred()) SWIG_fail;
31167 }
31168 {
31169 resultobj = wxPyMake_wxObject(result, 0);
31170 }
31171 return resultobj;
31172 fail:
31173 return NULL;
31174 }
31175
31176
31177 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31178 PyObject *resultobj;
31179 wxWindow *arg1 = (wxWindow *) 0 ;
31180 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31181 PyObject * obj0 = 0 ;
31182 PyObject * obj1 = 0 ;
31183 char *kwnames[] = {
31184 (char *) "self",(char *) "dropTarget", NULL
31185 };
31186
31187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31189 if (SWIG_arg_fail(1)) SWIG_fail;
31190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31191 if (SWIG_arg_fail(2)) SWIG_fail;
31192 {
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 (arg1)->SetDropTarget(arg2);
31195
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 Py_INCREF(Py_None); resultobj = Py_None;
31200 return resultobj;
31201 fail:
31202 return NULL;
31203 }
31204
31205
31206 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31207 PyObject *resultobj;
31208 wxWindow *arg1 = (wxWindow *) 0 ;
31209 wxPyDropTarget *result;
31210 PyObject * obj0 = 0 ;
31211 char *kwnames[] = {
31212 (char *) "self", NULL
31213 };
31214
31215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31217 if (SWIG_arg_fail(1)) SWIG_fail;
31218 {
31219 PyThreadState* __tstate = wxPyBeginAllowThreads();
31220 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31221
31222 wxPyEndAllowThreads(__tstate);
31223 if (PyErr_Occurred()) SWIG_fail;
31224 }
31225 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31226 return resultobj;
31227 fail:
31228 return NULL;
31229 }
31230
31231
31232 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31233 PyObject *resultobj;
31234 wxWindow *arg1 = (wxWindow *) 0 ;
31235 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31236 PyObject * obj0 = 0 ;
31237 PyObject * obj1 = 0 ;
31238 char *kwnames[] = {
31239 (char *) "self",(char *) "constraints", NULL
31240 };
31241
31242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31244 if (SWIG_arg_fail(1)) SWIG_fail;
31245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31246 if (SWIG_arg_fail(2)) SWIG_fail;
31247 {
31248 PyThreadState* __tstate = wxPyBeginAllowThreads();
31249 (arg1)->SetConstraints(arg2);
31250
31251 wxPyEndAllowThreads(__tstate);
31252 if (PyErr_Occurred()) SWIG_fail;
31253 }
31254 Py_INCREF(Py_None); resultobj = Py_None;
31255 return resultobj;
31256 fail:
31257 return NULL;
31258 }
31259
31260
31261 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31262 PyObject *resultobj;
31263 wxWindow *arg1 = (wxWindow *) 0 ;
31264 wxLayoutConstraints *result;
31265 PyObject * obj0 = 0 ;
31266 char *kwnames[] = {
31267 (char *) "self", NULL
31268 };
31269
31270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31272 if (SWIG_arg_fail(1)) SWIG_fail;
31273 {
31274 PyThreadState* __tstate = wxPyBeginAllowThreads();
31275 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31276
31277 wxPyEndAllowThreads(__tstate);
31278 if (PyErr_Occurred()) SWIG_fail;
31279 }
31280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31281 return resultobj;
31282 fail:
31283 return NULL;
31284 }
31285
31286
31287 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31288 PyObject *resultobj;
31289 wxWindow *arg1 = (wxWindow *) 0 ;
31290 bool arg2 ;
31291 PyObject * obj0 = 0 ;
31292 PyObject * obj1 = 0 ;
31293 char *kwnames[] = {
31294 (char *) "self",(char *) "autoLayout", NULL
31295 };
31296
31297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31299 if (SWIG_arg_fail(1)) SWIG_fail;
31300 {
31301 arg2 = (bool)(SWIG_As_bool(obj1));
31302 if (SWIG_arg_fail(2)) SWIG_fail;
31303 }
31304 {
31305 PyThreadState* __tstate = wxPyBeginAllowThreads();
31306 (arg1)->SetAutoLayout(arg2);
31307
31308 wxPyEndAllowThreads(__tstate);
31309 if (PyErr_Occurred()) SWIG_fail;
31310 }
31311 Py_INCREF(Py_None); resultobj = Py_None;
31312 return resultobj;
31313 fail:
31314 return NULL;
31315 }
31316
31317
31318 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31319 PyObject *resultobj;
31320 wxWindow *arg1 = (wxWindow *) 0 ;
31321 bool result;
31322 PyObject * obj0 = 0 ;
31323 char *kwnames[] = {
31324 (char *) "self", NULL
31325 };
31326
31327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31329 if (SWIG_arg_fail(1)) SWIG_fail;
31330 {
31331 PyThreadState* __tstate = wxPyBeginAllowThreads();
31332 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31333
31334 wxPyEndAllowThreads(__tstate);
31335 if (PyErr_Occurred()) SWIG_fail;
31336 }
31337 {
31338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31339 }
31340 return resultobj;
31341 fail:
31342 return NULL;
31343 }
31344
31345
31346 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31347 PyObject *resultobj;
31348 wxWindow *arg1 = (wxWindow *) 0 ;
31349 bool result;
31350 PyObject * obj0 = 0 ;
31351 char *kwnames[] = {
31352 (char *) "self", NULL
31353 };
31354
31355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31357 if (SWIG_arg_fail(1)) SWIG_fail;
31358 {
31359 PyThreadState* __tstate = wxPyBeginAllowThreads();
31360 result = (bool)(arg1)->Layout();
31361
31362 wxPyEndAllowThreads(__tstate);
31363 if (PyErr_Occurred()) SWIG_fail;
31364 }
31365 {
31366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31367 }
31368 return resultobj;
31369 fail:
31370 return NULL;
31371 }
31372
31373
31374 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31375 PyObject *resultobj;
31376 wxWindow *arg1 = (wxWindow *) 0 ;
31377 wxSizer *arg2 = (wxSizer *) 0 ;
31378 bool arg3 = (bool) true ;
31379 PyObject * obj0 = 0 ;
31380 PyObject * obj1 = 0 ;
31381 PyObject * obj2 = 0 ;
31382 char *kwnames[] = {
31383 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31384 };
31385
31386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31388 if (SWIG_arg_fail(1)) SWIG_fail;
31389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31390 if (SWIG_arg_fail(2)) SWIG_fail;
31391 if (obj2) {
31392 {
31393 arg3 = (bool)(SWIG_As_bool(obj2));
31394 if (SWIG_arg_fail(3)) SWIG_fail;
31395 }
31396 }
31397 {
31398 PyThreadState* __tstate = wxPyBeginAllowThreads();
31399 (arg1)->SetSizer(arg2,arg3);
31400
31401 wxPyEndAllowThreads(__tstate);
31402 if (PyErr_Occurred()) SWIG_fail;
31403 }
31404 Py_INCREF(Py_None); resultobj = Py_None;
31405 return resultobj;
31406 fail:
31407 return NULL;
31408 }
31409
31410
31411 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31412 PyObject *resultobj;
31413 wxWindow *arg1 = (wxWindow *) 0 ;
31414 wxSizer *arg2 = (wxSizer *) 0 ;
31415 bool arg3 = (bool) true ;
31416 PyObject * obj0 = 0 ;
31417 PyObject * obj1 = 0 ;
31418 PyObject * obj2 = 0 ;
31419 char *kwnames[] = {
31420 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31421 };
31422
31423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31425 if (SWIG_arg_fail(1)) SWIG_fail;
31426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31427 if (SWIG_arg_fail(2)) SWIG_fail;
31428 if (obj2) {
31429 {
31430 arg3 = (bool)(SWIG_As_bool(obj2));
31431 if (SWIG_arg_fail(3)) SWIG_fail;
31432 }
31433 }
31434 {
31435 PyThreadState* __tstate = wxPyBeginAllowThreads();
31436 (arg1)->SetSizerAndFit(arg2,arg3);
31437
31438 wxPyEndAllowThreads(__tstate);
31439 if (PyErr_Occurred()) SWIG_fail;
31440 }
31441 Py_INCREF(Py_None); resultobj = Py_None;
31442 return resultobj;
31443 fail:
31444 return NULL;
31445 }
31446
31447
31448 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31449 PyObject *resultobj;
31450 wxWindow *arg1 = (wxWindow *) 0 ;
31451 wxSizer *result;
31452 PyObject * obj0 = 0 ;
31453 char *kwnames[] = {
31454 (char *) "self", NULL
31455 };
31456
31457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31459 if (SWIG_arg_fail(1)) SWIG_fail;
31460 {
31461 PyThreadState* __tstate = wxPyBeginAllowThreads();
31462 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31463
31464 wxPyEndAllowThreads(__tstate);
31465 if (PyErr_Occurred()) SWIG_fail;
31466 }
31467 {
31468 resultobj = wxPyMake_wxSizer(result, 0);
31469 }
31470 return resultobj;
31471 fail:
31472 return NULL;
31473 }
31474
31475
31476 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31477 PyObject *resultobj;
31478 wxWindow *arg1 = (wxWindow *) 0 ;
31479 wxSizer *arg2 = (wxSizer *) 0 ;
31480 PyObject * obj0 = 0 ;
31481 PyObject * obj1 = 0 ;
31482 char *kwnames[] = {
31483 (char *) "self",(char *) "sizer", NULL
31484 };
31485
31486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31488 if (SWIG_arg_fail(1)) SWIG_fail;
31489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31490 if (SWIG_arg_fail(2)) SWIG_fail;
31491 {
31492 PyThreadState* __tstate = wxPyBeginAllowThreads();
31493 (arg1)->SetContainingSizer(arg2);
31494
31495 wxPyEndAllowThreads(__tstate);
31496 if (PyErr_Occurred()) SWIG_fail;
31497 }
31498 Py_INCREF(Py_None); resultobj = Py_None;
31499 return resultobj;
31500 fail:
31501 return NULL;
31502 }
31503
31504
31505 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31506 PyObject *resultobj;
31507 wxWindow *arg1 = (wxWindow *) 0 ;
31508 wxSizer *result;
31509 PyObject * obj0 = 0 ;
31510 char *kwnames[] = {
31511 (char *) "self", NULL
31512 };
31513
31514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31516 if (SWIG_arg_fail(1)) SWIG_fail;
31517 {
31518 PyThreadState* __tstate = wxPyBeginAllowThreads();
31519 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31520
31521 wxPyEndAllowThreads(__tstate);
31522 if (PyErr_Occurred()) SWIG_fail;
31523 }
31524 {
31525 resultobj = wxPyMake_wxSizer(result, 0);
31526 }
31527 return resultobj;
31528 fail:
31529 return NULL;
31530 }
31531
31532
31533 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31534 PyObject *resultobj;
31535 wxWindow *arg1 = (wxWindow *) 0 ;
31536 PyObject * obj0 = 0 ;
31537 char *kwnames[] = {
31538 (char *) "self", NULL
31539 };
31540
31541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31543 if (SWIG_arg_fail(1)) SWIG_fail;
31544 {
31545 PyThreadState* __tstate = wxPyBeginAllowThreads();
31546 (arg1)->InheritAttributes();
31547
31548 wxPyEndAllowThreads(__tstate);
31549 if (PyErr_Occurred()) SWIG_fail;
31550 }
31551 Py_INCREF(Py_None); resultobj = Py_None;
31552 return resultobj;
31553 fail:
31554 return NULL;
31555 }
31556
31557
31558 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31559 PyObject *resultobj;
31560 wxWindow *arg1 = (wxWindow *) 0 ;
31561 bool result;
31562 PyObject * obj0 = 0 ;
31563 char *kwnames[] = {
31564 (char *) "self", NULL
31565 };
31566
31567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31569 if (SWIG_arg_fail(1)) SWIG_fail;
31570 {
31571 PyThreadState* __tstate = wxPyBeginAllowThreads();
31572 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31573
31574 wxPyEndAllowThreads(__tstate);
31575 if (PyErr_Occurred()) SWIG_fail;
31576 }
31577 {
31578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31579 }
31580 return resultobj;
31581 fail:
31582 return NULL;
31583 }
31584
31585
31586 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31587 PyObject *obj;
31588 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31589 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31590 Py_INCREF(obj);
31591 return Py_BuildValue((char *)"");
31592 }
31593 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31594 PyObject *resultobj;
31595 long arg1 ;
31596 wxWindow *arg2 = (wxWindow *) NULL ;
31597 wxWindow *result;
31598 PyObject * obj0 = 0 ;
31599 PyObject * obj1 = 0 ;
31600 char *kwnames[] = {
31601 (char *) "id",(char *) "parent", NULL
31602 };
31603
31604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31605 {
31606 arg1 = (long)(SWIG_As_long(obj0));
31607 if (SWIG_arg_fail(1)) SWIG_fail;
31608 }
31609 if (obj1) {
31610 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31611 if (SWIG_arg_fail(2)) SWIG_fail;
31612 }
31613 {
31614 if (!wxPyCheckForApp()) SWIG_fail;
31615 PyThreadState* __tstate = wxPyBeginAllowThreads();
31616 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31617
31618 wxPyEndAllowThreads(__tstate);
31619 if (PyErr_Occurred()) SWIG_fail;
31620 }
31621 {
31622 resultobj = wxPyMake_wxObject(result, 0);
31623 }
31624 return resultobj;
31625 fail:
31626 return NULL;
31627 }
31628
31629
31630 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31631 PyObject *resultobj;
31632 wxString *arg1 = 0 ;
31633 wxWindow *arg2 = (wxWindow *) NULL ;
31634 wxWindow *result;
31635 bool temp1 = false ;
31636 PyObject * obj0 = 0 ;
31637 PyObject * obj1 = 0 ;
31638 char *kwnames[] = {
31639 (char *) "name",(char *) "parent", NULL
31640 };
31641
31642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31643 {
31644 arg1 = wxString_in_helper(obj0);
31645 if (arg1 == NULL) SWIG_fail;
31646 temp1 = true;
31647 }
31648 if (obj1) {
31649 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31650 if (SWIG_arg_fail(2)) SWIG_fail;
31651 }
31652 {
31653 if (!wxPyCheckForApp()) SWIG_fail;
31654 PyThreadState* __tstate = wxPyBeginAllowThreads();
31655 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31656
31657 wxPyEndAllowThreads(__tstate);
31658 if (PyErr_Occurred()) SWIG_fail;
31659 }
31660 {
31661 resultobj = wxPyMake_wxObject(result, 0);
31662 }
31663 {
31664 if (temp1)
31665 delete arg1;
31666 }
31667 return resultobj;
31668 fail:
31669 {
31670 if (temp1)
31671 delete arg1;
31672 }
31673 return NULL;
31674 }
31675
31676
31677 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31678 PyObject *resultobj;
31679 wxString *arg1 = 0 ;
31680 wxWindow *arg2 = (wxWindow *) NULL ;
31681 wxWindow *result;
31682 bool temp1 = false ;
31683 PyObject * obj0 = 0 ;
31684 PyObject * obj1 = 0 ;
31685 char *kwnames[] = {
31686 (char *) "label",(char *) "parent", NULL
31687 };
31688
31689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31690 {
31691 arg1 = wxString_in_helper(obj0);
31692 if (arg1 == NULL) SWIG_fail;
31693 temp1 = true;
31694 }
31695 if (obj1) {
31696 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31697 if (SWIG_arg_fail(2)) SWIG_fail;
31698 }
31699 {
31700 if (!wxPyCheckForApp()) SWIG_fail;
31701 PyThreadState* __tstate = wxPyBeginAllowThreads();
31702 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31703
31704 wxPyEndAllowThreads(__tstate);
31705 if (PyErr_Occurred()) SWIG_fail;
31706 }
31707 {
31708 resultobj = wxPyMake_wxObject(result, 0);
31709 }
31710 {
31711 if (temp1)
31712 delete arg1;
31713 }
31714 return resultobj;
31715 fail:
31716 {
31717 if (temp1)
31718 delete arg1;
31719 }
31720 return NULL;
31721 }
31722
31723
31724 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31725 PyObject *resultobj;
31726 wxWindow *arg1 = (wxWindow *) 0 ;
31727 unsigned long arg2 ;
31728 wxWindow *result;
31729 PyObject * obj0 = 0 ;
31730 PyObject * obj1 = 0 ;
31731 char *kwnames[] = {
31732 (char *) "parent",(char *) "_hWnd", NULL
31733 };
31734
31735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31737 if (SWIG_arg_fail(1)) SWIG_fail;
31738 {
31739 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31740 if (SWIG_arg_fail(2)) SWIG_fail;
31741 }
31742 {
31743 PyThreadState* __tstate = wxPyBeginAllowThreads();
31744 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31745
31746 wxPyEndAllowThreads(__tstate);
31747 if (PyErr_Occurred()) SWIG_fail;
31748 }
31749 {
31750 resultobj = wxPyMake_wxObject(result, 0);
31751 }
31752 return resultobj;
31753 fail:
31754 return NULL;
31755 }
31756
31757
31758 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31759 PyObject *resultobj;
31760 wxValidator *result;
31761 char *kwnames[] = {
31762 NULL
31763 };
31764
31765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31766 {
31767 PyThreadState* __tstate = wxPyBeginAllowThreads();
31768 result = (wxValidator *)new wxValidator();
31769
31770 wxPyEndAllowThreads(__tstate);
31771 if (PyErr_Occurred()) SWIG_fail;
31772 }
31773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31774 return resultobj;
31775 fail:
31776 return NULL;
31777 }
31778
31779
31780 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31781 PyObject *resultobj;
31782 wxValidator *arg1 = (wxValidator *) 0 ;
31783 wxValidator *result;
31784 PyObject * obj0 = 0 ;
31785 char *kwnames[] = {
31786 (char *) "self", NULL
31787 };
31788
31789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31791 if (SWIG_arg_fail(1)) SWIG_fail;
31792 {
31793 PyThreadState* __tstate = wxPyBeginAllowThreads();
31794 result = (wxValidator *)(arg1)->Clone();
31795
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 {
31800 resultobj = wxPyMake_wxObject(result, 0);
31801 }
31802 return resultobj;
31803 fail:
31804 return NULL;
31805 }
31806
31807
31808 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31809 PyObject *resultobj;
31810 wxValidator *arg1 = (wxValidator *) 0 ;
31811 wxWindow *arg2 = (wxWindow *) 0 ;
31812 bool result;
31813 PyObject * obj0 = 0 ;
31814 PyObject * obj1 = 0 ;
31815 char *kwnames[] = {
31816 (char *) "self",(char *) "parent", NULL
31817 };
31818
31819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31821 if (SWIG_arg_fail(1)) SWIG_fail;
31822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31823 if (SWIG_arg_fail(2)) SWIG_fail;
31824 {
31825 PyThreadState* __tstate = wxPyBeginAllowThreads();
31826 result = (bool)(arg1)->Validate(arg2);
31827
31828 wxPyEndAllowThreads(__tstate);
31829 if (PyErr_Occurred()) SWIG_fail;
31830 }
31831 {
31832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31833 }
31834 return resultobj;
31835 fail:
31836 return NULL;
31837 }
31838
31839
31840 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31841 PyObject *resultobj;
31842 wxValidator *arg1 = (wxValidator *) 0 ;
31843 bool result;
31844 PyObject * obj0 = 0 ;
31845 char *kwnames[] = {
31846 (char *) "self", NULL
31847 };
31848
31849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31851 if (SWIG_arg_fail(1)) SWIG_fail;
31852 {
31853 PyThreadState* __tstate = wxPyBeginAllowThreads();
31854 result = (bool)(arg1)->TransferToWindow();
31855
31856 wxPyEndAllowThreads(__tstate);
31857 if (PyErr_Occurred()) SWIG_fail;
31858 }
31859 {
31860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31861 }
31862 return resultobj;
31863 fail:
31864 return NULL;
31865 }
31866
31867
31868 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31869 PyObject *resultobj;
31870 wxValidator *arg1 = (wxValidator *) 0 ;
31871 bool result;
31872 PyObject * obj0 = 0 ;
31873 char *kwnames[] = {
31874 (char *) "self", NULL
31875 };
31876
31877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31879 if (SWIG_arg_fail(1)) SWIG_fail;
31880 {
31881 PyThreadState* __tstate = wxPyBeginAllowThreads();
31882 result = (bool)(arg1)->TransferFromWindow();
31883
31884 wxPyEndAllowThreads(__tstate);
31885 if (PyErr_Occurred()) SWIG_fail;
31886 }
31887 {
31888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31889 }
31890 return resultobj;
31891 fail:
31892 return NULL;
31893 }
31894
31895
31896 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31897 PyObject *resultobj;
31898 wxValidator *arg1 = (wxValidator *) 0 ;
31899 wxWindow *result;
31900 PyObject * obj0 = 0 ;
31901 char *kwnames[] = {
31902 (char *) "self", NULL
31903 };
31904
31905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31907 if (SWIG_arg_fail(1)) SWIG_fail;
31908 {
31909 PyThreadState* __tstate = wxPyBeginAllowThreads();
31910 result = (wxWindow *)(arg1)->GetWindow();
31911
31912 wxPyEndAllowThreads(__tstate);
31913 if (PyErr_Occurred()) SWIG_fail;
31914 }
31915 {
31916 resultobj = wxPyMake_wxObject(result, 0);
31917 }
31918 return resultobj;
31919 fail:
31920 return NULL;
31921 }
31922
31923
31924 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31925 PyObject *resultobj;
31926 wxValidator *arg1 = (wxValidator *) 0 ;
31927 wxWindow *arg2 = (wxWindow *) 0 ;
31928 PyObject * obj0 = 0 ;
31929 PyObject * obj1 = 0 ;
31930 char *kwnames[] = {
31931 (char *) "self",(char *) "window", NULL
31932 };
31933
31934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31936 if (SWIG_arg_fail(1)) SWIG_fail;
31937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31938 if (SWIG_arg_fail(2)) SWIG_fail;
31939 {
31940 PyThreadState* __tstate = wxPyBeginAllowThreads();
31941 (arg1)->SetWindow(arg2);
31942
31943 wxPyEndAllowThreads(__tstate);
31944 if (PyErr_Occurred()) SWIG_fail;
31945 }
31946 Py_INCREF(Py_None); resultobj = Py_None;
31947 return resultobj;
31948 fail:
31949 return NULL;
31950 }
31951
31952
31953 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31954 PyObject *resultobj;
31955 bool result;
31956 char *kwnames[] = {
31957 NULL
31958 };
31959
31960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31961 {
31962 PyThreadState* __tstate = wxPyBeginAllowThreads();
31963 result = (bool)wxValidator::IsSilent();
31964
31965 wxPyEndAllowThreads(__tstate);
31966 if (PyErr_Occurred()) SWIG_fail;
31967 }
31968 {
31969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31970 }
31971 return resultobj;
31972 fail:
31973 return NULL;
31974 }
31975
31976
31977 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31978 PyObject *resultobj;
31979 int arg1 = (int) true ;
31980 PyObject * obj0 = 0 ;
31981 char *kwnames[] = {
31982 (char *) "doIt", NULL
31983 };
31984
31985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31986 if (obj0) {
31987 {
31988 arg1 = (int)(SWIG_As_int(obj0));
31989 if (SWIG_arg_fail(1)) SWIG_fail;
31990 }
31991 }
31992 {
31993 PyThreadState* __tstate = wxPyBeginAllowThreads();
31994 wxValidator::SetBellOnError(arg1);
31995
31996 wxPyEndAllowThreads(__tstate);
31997 if (PyErr_Occurred()) SWIG_fail;
31998 }
31999 Py_INCREF(Py_None); resultobj = Py_None;
32000 return resultobj;
32001 fail:
32002 return NULL;
32003 }
32004
32005
32006 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32007 PyObject *obj;
32008 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32009 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32010 Py_INCREF(obj);
32011 return Py_BuildValue((char *)"");
32012 }
32013 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32014 PyObject *resultobj;
32015 wxPyValidator *result;
32016 char *kwnames[] = {
32017 NULL
32018 };
32019
32020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32021 {
32022 PyThreadState* __tstate = wxPyBeginAllowThreads();
32023 result = (wxPyValidator *)new wxPyValidator();
32024
32025 wxPyEndAllowThreads(__tstate);
32026 if (PyErr_Occurred()) SWIG_fail;
32027 }
32028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32029 return resultobj;
32030 fail:
32031 return NULL;
32032 }
32033
32034
32035 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32036 PyObject *resultobj;
32037 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32038 PyObject *arg2 = (PyObject *) 0 ;
32039 PyObject *arg3 = (PyObject *) 0 ;
32040 int arg4 = (int) true ;
32041 PyObject * obj0 = 0 ;
32042 PyObject * obj1 = 0 ;
32043 PyObject * obj2 = 0 ;
32044 PyObject * obj3 = 0 ;
32045 char *kwnames[] = {
32046 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32047 };
32048
32049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32051 if (SWIG_arg_fail(1)) SWIG_fail;
32052 arg2 = obj1;
32053 arg3 = obj2;
32054 if (obj3) {
32055 {
32056 arg4 = (int)(SWIG_As_int(obj3));
32057 if (SWIG_arg_fail(4)) SWIG_fail;
32058 }
32059 }
32060 {
32061 PyThreadState* __tstate = wxPyBeginAllowThreads();
32062 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32063
32064 wxPyEndAllowThreads(__tstate);
32065 if (PyErr_Occurred()) SWIG_fail;
32066 }
32067 Py_INCREF(Py_None); resultobj = Py_None;
32068 return resultobj;
32069 fail:
32070 return NULL;
32071 }
32072
32073
32074 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32075 PyObject *obj;
32076 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32077 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32078 Py_INCREF(obj);
32079 return Py_BuildValue((char *)"");
32080 }
32081 static int _wrap_DefaultValidator_set(PyObject *) {
32082 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32083 return 1;
32084 }
32085
32086
32087 static PyObject *_wrap_DefaultValidator_get(void) {
32088 PyObject *pyobj;
32089
32090 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32091 return pyobj;
32092 }
32093
32094
32095 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32096 PyObject *resultobj;
32097 wxString const &arg1_defvalue = wxPyEmptyString ;
32098 wxString *arg1 = (wxString *) &arg1_defvalue ;
32099 long arg2 = (long) 0 ;
32100 wxMenu *result;
32101 bool temp1 = false ;
32102 PyObject * obj0 = 0 ;
32103 PyObject * obj1 = 0 ;
32104 char *kwnames[] = {
32105 (char *) "title",(char *) "style", NULL
32106 };
32107
32108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32109 if (obj0) {
32110 {
32111 arg1 = wxString_in_helper(obj0);
32112 if (arg1 == NULL) SWIG_fail;
32113 temp1 = true;
32114 }
32115 }
32116 if (obj1) {
32117 {
32118 arg2 = (long)(SWIG_As_long(obj1));
32119 if (SWIG_arg_fail(2)) SWIG_fail;
32120 }
32121 }
32122 {
32123 if (!wxPyCheckForApp()) SWIG_fail;
32124 PyThreadState* __tstate = wxPyBeginAllowThreads();
32125 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32126
32127 wxPyEndAllowThreads(__tstate);
32128 if (PyErr_Occurred()) SWIG_fail;
32129 }
32130 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32131 {
32132 if (temp1)
32133 delete arg1;
32134 }
32135 return resultobj;
32136 fail:
32137 {
32138 if (temp1)
32139 delete arg1;
32140 }
32141 return NULL;
32142 }
32143
32144
32145 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32146 PyObject *resultobj;
32147 wxMenu *arg1 = (wxMenu *) 0 ;
32148 int arg2 ;
32149 wxString *arg3 = 0 ;
32150 wxString const &arg4_defvalue = wxPyEmptyString ;
32151 wxString *arg4 = (wxString *) &arg4_defvalue ;
32152 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32153 wxMenuItem *result;
32154 bool temp3 = false ;
32155 bool temp4 = false ;
32156 PyObject * obj0 = 0 ;
32157 PyObject * obj1 = 0 ;
32158 PyObject * obj2 = 0 ;
32159 PyObject * obj3 = 0 ;
32160 PyObject * obj4 = 0 ;
32161 char *kwnames[] = {
32162 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32163 };
32164
32165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32167 if (SWIG_arg_fail(1)) SWIG_fail;
32168 {
32169 arg2 = (int)(SWIG_As_int(obj1));
32170 if (SWIG_arg_fail(2)) SWIG_fail;
32171 }
32172 {
32173 arg3 = wxString_in_helper(obj2);
32174 if (arg3 == NULL) SWIG_fail;
32175 temp3 = true;
32176 }
32177 if (obj3) {
32178 {
32179 arg4 = wxString_in_helper(obj3);
32180 if (arg4 == NULL) SWIG_fail;
32181 temp4 = true;
32182 }
32183 }
32184 if (obj4) {
32185 {
32186 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32187 if (SWIG_arg_fail(5)) SWIG_fail;
32188 }
32189 }
32190 {
32191 PyThreadState* __tstate = wxPyBeginAllowThreads();
32192 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32193
32194 wxPyEndAllowThreads(__tstate);
32195 if (PyErr_Occurred()) SWIG_fail;
32196 }
32197 {
32198 resultobj = wxPyMake_wxObject(result, 0);
32199 }
32200 {
32201 if (temp3)
32202 delete arg3;
32203 }
32204 {
32205 if (temp4)
32206 delete arg4;
32207 }
32208 return resultobj;
32209 fail:
32210 {
32211 if (temp3)
32212 delete arg3;
32213 }
32214 {
32215 if (temp4)
32216 delete arg4;
32217 }
32218 return NULL;
32219 }
32220
32221
32222 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32223 PyObject *resultobj;
32224 wxMenu *arg1 = (wxMenu *) 0 ;
32225 wxMenuItem *result;
32226 PyObject * obj0 = 0 ;
32227 char *kwnames[] = {
32228 (char *) "self", NULL
32229 };
32230
32231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32233 if (SWIG_arg_fail(1)) SWIG_fail;
32234 {
32235 PyThreadState* __tstate = wxPyBeginAllowThreads();
32236 result = (wxMenuItem *)(arg1)->AppendSeparator();
32237
32238 wxPyEndAllowThreads(__tstate);
32239 if (PyErr_Occurred()) SWIG_fail;
32240 }
32241 {
32242 resultobj = wxPyMake_wxObject(result, 0);
32243 }
32244 return resultobj;
32245 fail:
32246 return NULL;
32247 }
32248
32249
32250 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32251 PyObject *resultobj;
32252 wxMenu *arg1 = (wxMenu *) 0 ;
32253 int arg2 ;
32254 wxString *arg3 = 0 ;
32255 wxString const &arg4_defvalue = wxPyEmptyString ;
32256 wxString *arg4 = (wxString *) &arg4_defvalue ;
32257 wxMenuItem *result;
32258 bool temp3 = false ;
32259 bool temp4 = false ;
32260 PyObject * obj0 = 0 ;
32261 PyObject * obj1 = 0 ;
32262 PyObject * obj2 = 0 ;
32263 PyObject * obj3 = 0 ;
32264 char *kwnames[] = {
32265 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32266 };
32267
32268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32270 if (SWIG_arg_fail(1)) SWIG_fail;
32271 {
32272 arg2 = (int)(SWIG_As_int(obj1));
32273 if (SWIG_arg_fail(2)) SWIG_fail;
32274 }
32275 {
32276 arg3 = wxString_in_helper(obj2);
32277 if (arg3 == NULL) SWIG_fail;
32278 temp3 = true;
32279 }
32280 if (obj3) {
32281 {
32282 arg4 = wxString_in_helper(obj3);
32283 if (arg4 == NULL) SWIG_fail;
32284 temp4 = true;
32285 }
32286 }
32287 {
32288 PyThreadState* __tstate = wxPyBeginAllowThreads();
32289 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32290
32291 wxPyEndAllowThreads(__tstate);
32292 if (PyErr_Occurred()) SWIG_fail;
32293 }
32294 {
32295 resultobj = wxPyMake_wxObject(result, 0);
32296 }
32297 {
32298 if (temp3)
32299 delete arg3;
32300 }
32301 {
32302 if (temp4)
32303 delete arg4;
32304 }
32305 return resultobj;
32306 fail:
32307 {
32308 if (temp3)
32309 delete arg3;
32310 }
32311 {
32312 if (temp4)
32313 delete arg4;
32314 }
32315 return NULL;
32316 }
32317
32318
32319 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32320 PyObject *resultobj;
32321 wxMenu *arg1 = (wxMenu *) 0 ;
32322 int arg2 ;
32323 wxString *arg3 = 0 ;
32324 wxString const &arg4_defvalue = wxPyEmptyString ;
32325 wxString *arg4 = (wxString *) &arg4_defvalue ;
32326 wxMenuItem *result;
32327 bool temp3 = false ;
32328 bool temp4 = false ;
32329 PyObject * obj0 = 0 ;
32330 PyObject * obj1 = 0 ;
32331 PyObject * obj2 = 0 ;
32332 PyObject * obj3 = 0 ;
32333 char *kwnames[] = {
32334 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32335 };
32336
32337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32339 if (SWIG_arg_fail(1)) SWIG_fail;
32340 {
32341 arg2 = (int)(SWIG_As_int(obj1));
32342 if (SWIG_arg_fail(2)) SWIG_fail;
32343 }
32344 {
32345 arg3 = wxString_in_helper(obj2);
32346 if (arg3 == NULL) SWIG_fail;
32347 temp3 = true;
32348 }
32349 if (obj3) {
32350 {
32351 arg4 = wxString_in_helper(obj3);
32352 if (arg4 == NULL) SWIG_fail;
32353 temp4 = true;
32354 }
32355 }
32356 {
32357 PyThreadState* __tstate = wxPyBeginAllowThreads();
32358 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32359
32360 wxPyEndAllowThreads(__tstate);
32361 if (PyErr_Occurred()) SWIG_fail;
32362 }
32363 {
32364 resultobj = wxPyMake_wxObject(result, 0);
32365 }
32366 {
32367 if (temp3)
32368 delete arg3;
32369 }
32370 {
32371 if (temp4)
32372 delete arg4;
32373 }
32374 return resultobj;
32375 fail:
32376 {
32377 if (temp3)
32378 delete arg3;
32379 }
32380 {
32381 if (temp4)
32382 delete arg4;
32383 }
32384 return NULL;
32385 }
32386
32387
32388 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32389 PyObject *resultobj;
32390 wxMenu *arg1 = (wxMenu *) 0 ;
32391 int arg2 ;
32392 wxString *arg3 = 0 ;
32393 wxMenu *arg4 = (wxMenu *) 0 ;
32394 wxString const &arg5_defvalue = wxPyEmptyString ;
32395 wxString *arg5 = (wxString *) &arg5_defvalue ;
32396 wxMenuItem *result;
32397 bool temp3 = false ;
32398 bool temp5 = false ;
32399 PyObject * obj0 = 0 ;
32400 PyObject * obj1 = 0 ;
32401 PyObject * obj2 = 0 ;
32402 PyObject * obj3 = 0 ;
32403 PyObject * obj4 = 0 ;
32404 char *kwnames[] = {
32405 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32406 };
32407
32408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32410 if (SWIG_arg_fail(1)) SWIG_fail;
32411 {
32412 arg2 = (int)(SWIG_As_int(obj1));
32413 if (SWIG_arg_fail(2)) SWIG_fail;
32414 }
32415 {
32416 arg3 = wxString_in_helper(obj2);
32417 if (arg3 == NULL) SWIG_fail;
32418 temp3 = true;
32419 }
32420 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32421 if (SWIG_arg_fail(4)) SWIG_fail;
32422 if (obj4) {
32423 {
32424 arg5 = wxString_in_helper(obj4);
32425 if (arg5 == NULL) SWIG_fail;
32426 temp5 = true;
32427 }
32428 }
32429 {
32430 PyThreadState* __tstate = wxPyBeginAllowThreads();
32431 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32432
32433 wxPyEndAllowThreads(__tstate);
32434 if (PyErr_Occurred()) SWIG_fail;
32435 }
32436 {
32437 resultobj = wxPyMake_wxObject(result, 0);
32438 }
32439 {
32440 if (temp3)
32441 delete arg3;
32442 }
32443 {
32444 if (temp5)
32445 delete arg5;
32446 }
32447 return resultobj;
32448 fail:
32449 {
32450 if (temp3)
32451 delete arg3;
32452 }
32453 {
32454 if (temp5)
32455 delete arg5;
32456 }
32457 return NULL;
32458 }
32459
32460
32461 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32462 PyObject *resultobj;
32463 wxMenu *arg1 = (wxMenu *) 0 ;
32464 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32465 wxMenuItem *result;
32466 PyObject * obj0 = 0 ;
32467 PyObject * obj1 = 0 ;
32468 char *kwnames[] = {
32469 (char *) "self",(char *) "item", NULL
32470 };
32471
32472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32474 if (SWIG_arg_fail(1)) SWIG_fail;
32475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32476 if (SWIG_arg_fail(2)) SWIG_fail;
32477 {
32478 PyThreadState* __tstate = wxPyBeginAllowThreads();
32479 result = (wxMenuItem *)(arg1)->Append(arg2);
32480
32481 wxPyEndAllowThreads(__tstate);
32482 if (PyErr_Occurred()) SWIG_fail;
32483 }
32484 {
32485 resultobj = wxPyMake_wxObject(result, 0);
32486 }
32487 return resultobj;
32488 fail:
32489 return NULL;
32490 }
32491
32492
32493 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32494 PyObject *resultobj;
32495 wxMenu *arg1 = (wxMenu *) 0 ;
32496 PyObject * obj0 = 0 ;
32497 char *kwnames[] = {
32498 (char *) "self", NULL
32499 };
32500
32501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32503 if (SWIG_arg_fail(1)) SWIG_fail;
32504 {
32505 PyThreadState* __tstate = wxPyBeginAllowThreads();
32506 (arg1)->Break();
32507
32508 wxPyEndAllowThreads(__tstate);
32509 if (PyErr_Occurred()) SWIG_fail;
32510 }
32511 Py_INCREF(Py_None); resultobj = Py_None;
32512 return resultobj;
32513 fail:
32514 return NULL;
32515 }
32516
32517
32518 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32519 PyObject *resultobj;
32520 wxMenu *arg1 = (wxMenu *) 0 ;
32521 size_t arg2 ;
32522 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32523 wxMenuItem *result;
32524 PyObject * obj0 = 0 ;
32525 PyObject * obj1 = 0 ;
32526 PyObject * obj2 = 0 ;
32527 char *kwnames[] = {
32528 (char *) "self",(char *) "pos",(char *) "item", NULL
32529 };
32530
32531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32533 if (SWIG_arg_fail(1)) SWIG_fail;
32534 {
32535 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32536 if (SWIG_arg_fail(2)) SWIG_fail;
32537 }
32538 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32539 if (SWIG_arg_fail(3)) SWIG_fail;
32540 {
32541 PyThreadState* __tstate = wxPyBeginAllowThreads();
32542 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32543
32544 wxPyEndAllowThreads(__tstate);
32545 if (PyErr_Occurred()) SWIG_fail;
32546 }
32547 {
32548 resultobj = wxPyMake_wxObject(result, 0);
32549 }
32550 return resultobj;
32551 fail:
32552 return NULL;
32553 }
32554
32555
32556 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32557 PyObject *resultobj;
32558 wxMenu *arg1 = (wxMenu *) 0 ;
32559 size_t arg2 ;
32560 int arg3 ;
32561 wxString *arg4 = 0 ;
32562 wxString const &arg5_defvalue = wxPyEmptyString ;
32563 wxString *arg5 = (wxString *) &arg5_defvalue ;
32564 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32565 wxMenuItem *result;
32566 bool temp4 = false ;
32567 bool temp5 = false ;
32568 PyObject * obj0 = 0 ;
32569 PyObject * obj1 = 0 ;
32570 PyObject * obj2 = 0 ;
32571 PyObject * obj3 = 0 ;
32572 PyObject * obj4 = 0 ;
32573 PyObject * obj5 = 0 ;
32574 char *kwnames[] = {
32575 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32576 };
32577
32578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32580 if (SWIG_arg_fail(1)) SWIG_fail;
32581 {
32582 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32583 if (SWIG_arg_fail(2)) SWIG_fail;
32584 }
32585 {
32586 arg3 = (int)(SWIG_As_int(obj2));
32587 if (SWIG_arg_fail(3)) SWIG_fail;
32588 }
32589 {
32590 arg4 = wxString_in_helper(obj3);
32591 if (arg4 == NULL) SWIG_fail;
32592 temp4 = true;
32593 }
32594 if (obj4) {
32595 {
32596 arg5 = wxString_in_helper(obj4);
32597 if (arg5 == NULL) SWIG_fail;
32598 temp5 = true;
32599 }
32600 }
32601 if (obj5) {
32602 {
32603 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32604 if (SWIG_arg_fail(6)) SWIG_fail;
32605 }
32606 }
32607 {
32608 PyThreadState* __tstate = wxPyBeginAllowThreads();
32609 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32610
32611 wxPyEndAllowThreads(__tstate);
32612 if (PyErr_Occurred()) SWIG_fail;
32613 }
32614 {
32615 resultobj = wxPyMake_wxObject(result, 0);
32616 }
32617 {
32618 if (temp4)
32619 delete arg4;
32620 }
32621 {
32622 if (temp5)
32623 delete arg5;
32624 }
32625 return resultobj;
32626 fail:
32627 {
32628 if (temp4)
32629 delete arg4;
32630 }
32631 {
32632 if (temp5)
32633 delete arg5;
32634 }
32635 return NULL;
32636 }
32637
32638
32639 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32640 PyObject *resultobj;
32641 wxMenu *arg1 = (wxMenu *) 0 ;
32642 size_t arg2 ;
32643 wxMenuItem *result;
32644 PyObject * obj0 = 0 ;
32645 PyObject * obj1 = 0 ;
32646 char *kwnames[] = {
32647 (char *) "self",(char *) "pos", NULL
32648 };
32649
32650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32652 if (SWIG_arg_fail(1)) SWIG_fail;
32653 {
32654 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32655 if (SWIG_arg_fail(2)) SWIG_fail;
32656 }
32657 {
32658 PyThreadState* __tstate = wxPyBeginAllowThreads();
32659 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32660
32661 wxPyEndAllowThreads(__tstate);
32662 if (PyErr_Occurred()) SWIG_fail;
32663 }
32664 {
32665 resultobj = wxPyMake_wxObject(result, 0);
32666 }
32667 return resultobj;
32668 fail:
32669 return NULL;
32670 }
32671
32672
32673 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32674 PyObject *resultobj;
32675 wxMenu *arg1 = (wxMenu *) 0 ;
32676 size_t arg2 ;
32677 int arg3 ;
32678 wxString *arg4 = 0 ;
32679 wxString const &arg5_defvalue = wxPyEmptyString ;
32680 wxString *arg5 = (wxString *) &arg5_defvalue ;
32681 wxMenuItem *result;
32682 bool temp4 = false ;
32683 bool temp5 = false ;
32684 PyObject * obj0 = 0 ;
32685 PyObject * obj1 = 0 ;
32686 PyObject * obj2 = 0 ;
32687 PyObject * obj3 = 0 ;
32688 PyObject * obj4 = 0 ;
32689 char *kwnames[] = {
32690 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32691 };
32692
32693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32695 if (SWIG_arg_fail(1)) SWIG_fail;
32696 {
32697 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32698 if (SWIG_arg_fail(2)) SWIG_fail;
32699 }
32700 {
32701 arg3 = (int)(SWIG_As_int(obj2));
32702 if (SWIG_arg_fail(3)) SWIG_fail;
32703 }
32704 {
32705 arg4 = wxString_in_helper(obj3);
32706 if (arg4 == NULL) SWIG_fail;
32707 temp4 = true;
32708 }
32709 if (obj4) {
32710 {
32711 arg5 = wxString_in_helper(obj4);
32712 if (arg5 == NULL) SWIG_fail;
32713 temp5 = true;
32714 }
32715 }
32716 {
32717 PyThreadState* __tstate = wxPyBeginAllowThreads();
32718 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32719
32720 wxPyEndAllowThreads(__tstate);
32721 if (PyErr_Occurred()) SWIG_fail;
32722 }
32723 {
32724 resultobj = wxPyMake_wxObject(result, 0);
32725 }
32726 {
32727 if (temp4)
32728 delete arg4;
32729 }
32730 {
32731 if (temp5)
32732 delete arg5;
32733 }
32734 return resultobj;
32735 fail:
32736 {
32737 if (temp4)
32738 delete arg4;
32739 }
32740 {
32741 if (temp5)
32742 delete arg5;
32743 }
32744 return NULL;
32745 }
32746
32747
32748 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32749 PyObject *resultobj;
32750 wxMenu *arg1 = (wxMenu *) 0 ;
32751 size_t arg2 ;
32752 int arg3 ;
32753 wxString *arg4 = 0 ;
32754 wxString const &arg5_defvalue = wxPyEmptyString ;
32755 wxString *arg5 = (wxString *) &arg5_defvalue ;
32756 wxMenuItem *result;
32757 bool temp4 = false ;
32758 bool temp5 = false ;
32759 PyObject * obj0 = 0 ;
32760 PyObject * obj1 = 0 ;
32761 PyObject * obj2 = 0 ;
32762 PyObject * obj3 = 0 ;
32763 PyObject * obj4 = 0 ;
32764 char *kwnames[] = {
32765 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32766 };
32767
32768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32770 if (SWIG_arg_fail(1)) SWIG_fail;
32771 {
32772 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32773 if (SWIG_arg_fail(2)) SWIG_fail;
32774 }
32775 {
32776 arg3 = (int)(SWIG_As_int(obj2));
32777 if (SWIG_arg_fail(3)) SWIG_fail;
32778 }
32779 {
32780 arg4 = wxString_in_helper(obj3);
32781 if (arg4 == NULL) SWIG_fail;
32782 temp4 = true;
32783 }
32784 if (obj4) {
32785 {
32786 arg5 = wxString_in_helper(obj4);
32787 if (arg5 == NULL) SWIG_fail;
32788 temp5 = true;
32789 }
32790 }
32791 {
32792 PyThreadState* __tstate = wxPyBeginAllowThreads();
32793 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32794
32795 wxPyEndAllowThreads(__tstate);
32796 if (PyErr_Occurred()) SWIG_fail;
32797 }
32798 {
32799 resultobj = wxPyMake_wxObject(result, 0);
32800 }
32801 {
32802 if (temp4)
32803 delete arg4;
32804 }
32805 {
32806 if (temp5)
32807 delete arg5;
32808 }
32809 return resultobj;
32810 fail:
32811 {
32812 if (temp4)
32813 delete arg4;
32814 }
32815 {
32816 if (temp5)
32817 delete arg5;
32818 }
32819 return NULL;
32820 }
32821
32822
32823 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32824 PyObject *resultobj;
32825 wxMenu *arg1 = (wxMenu *) 0 ;
32826 size_t arg2 ;
32827 int arg3 ;
32828 wxString *arg4 = 0 ;
32829 wxMenu *arg5 = (wxMenu *) 0 ;
32830 wxString const &arg6_defvalue = wxPyEmptyString ;
32831 wxString *arg6 = (wxString *) &arg6_defvalue ;
32832 wxMenuItem *result;
32833 bool temp4 = false ;
32834 bool temp6 = false ;
32835 PyObject * obj0 = 0 ;
32836 PyObject * obj1 = 0 ;
32837 PyObject * obj2 = 0 ;
32838 PyObject * obj3 = 0 ;
32839 PyObject * obj4 = 0 ;
32840 PyObject * obj5 = 0 ;
32841 char *kwnames[] = {
32842 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32843 };
32844
32845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32847 if (SWIG_arg_fail(1)) SWIG_fail;
32848 {
32849 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32850 if (SWIG_arg_fail(2)) SWIG_fail;
32851 }
32852 {
32853 arg3 = (int)(SWIG_As_int(obj2));
32854 if (SWIG_arg_fail(3)) SWIG_fail;
32855 }
32856 {
32857 arg4 = wxString_in_helper(obj3);
32858 if (arg4 == NULL) SWIG_fail;
32859 temp4 = true;
32860 }
32861 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32862 if (SWIG_arg_fail(5)) SWIG_fail;
32863 if (obj5) {
32864 {
32865 arg6 = wxString_in_helper(obj5);
32866 if (arg6 == NULL) SWIG_fail;
32867 temp6 = true;
32868 }
32869 }
32870 {
32871 PyThreadState* __tstate = wxPyBeginAllowThreads();
32872 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32873
32874 wxPyEndAllowThreads(__tstate);
32875 if (PyErr_Occurred()) SWIG_fail;
32876 }
32877 {
32878 resultobj = wxPyMake_wxObject(result, 0);
32879 }
32880 {
32881 if (temp4)
32882 delete arg4;
32883 }
32884 {
32885 if (temp6)
32886 delete arg6;
32887 }
32888 return resultobj;
32889 fail:
32890 {
32891 if (temp4)
32892 delete arg4;
32893 }
32894 {
32895 if (temp6)
32896 delete arg6;
32897 }
32898 return NULL;
32899 }
32900
32901
32902 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32903 PyObject *resultobj;
32904 wxMenu *arg1 = (wxMenu *) 0 ;
32905 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32906 wxMenuItem *result;
32907 PyObject * obj0 = 0 ;
32908 PyObject * obj1 = 0 ;
32909 char *kwnames[] = {
32910 (char *) "self",(char *) "item", NULL
32911 };
32912
32913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32915 if (SWIG_arg_fail(1)) SWIG_fail;
32916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32917 if (SWIG_arg_fail(2)) SWIG_fail;
32918 {
32919 PyThreadState* __tstate = wxPyBeginAllowThreads();
32920 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32921
32922 wxPyEndAllowThreads(__tstate);
32923 if (PyErr_Occurred()) SWIG_fail;
32924 }
32925 {
32926 resultobj = wxPyMake_wxObject(result, 0);
32927 }
32928 return resultobj;
32929 fail:
32930 return NULL;
32931 }
32932
32933
32934 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32935 PyObject *resultobj;
32936 wxMenu *arg1 = (wxMenu *) 0 ;
32937 int arg2 ;
32938 wxString *arg3 = 0 ;
32939 wxString const &arg4_defvalue = wxPyEmptyString ;
32940 wxString *arg4 = (wxString *) &arg4_defvalue ;
32941 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32942 wxMenuItem *result;
32943 bool temp3 = false ;
32944 bool temp4 = false ;
32945 PyObject * obj0 = 0 ;
32946 PyObject * obj1 = 0 ;
32947 PyObject * obj2 = 0 ;
32948 PyObject * obj3 = 0 ;
32949 PyObject * obj4 = 0 ;
32950 char *kwnames[] = {
32951 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32952 };
32953
32954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32956 if (SWIG_arg_fail(1)) SWIG_fail;
32957 {
32958 arg2 = (int)(SWIG_As_int(obj1));
32959 if (SWIG_arg_fail(2)) SWIG_fail;
32960 }
32961 {
32962 arg3 = wxString_in_helper(obj2);
32963 if (arg3 == NULL) SWIG_fail;
32964 temp3 = true;
32965 }
32966 if (obj3) {
32967 {
32968 arg4 = wxString_in_helper(obj3);
32969 if (arg4 == NULL) SWIG_fail;
32970 temp4 = true;
32971 }
32972 }
32973 if (obj4) {
32974 {
32975 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32976 if (SWIG_arg_fail(5)) SWIG_fail;
32977 }
32978 }
32979 {
32980 PyThreadState* __tstate = wxPyBeginAllowThreads();
32981 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32982
32983 wxPyEndAllowThreads(__tstate);
32984 if (PyErr_Occurred()) SWIG_fail;
32985 }
32986 {
32987 resultobj = wxPyMake_wxObject(result, 0);
32988 }
32989 {
32990 if (temp3)
32991 delete arg3;
32992 }
32993 {
32994 if (temp4)
32995 delete arg4;
32996 }
32997 return resultobj;
32998 fail:
32999 {
33000 if (temp3)
33001 delete arg3;
33002 }
33003 {
33004 if (temp4)
33005 delete arg4;
33006 }
33007 return NULL;
33008 }
33009
33010
33011 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33012 PyObject *resultobj;
33013 wxMenu *arg1 = (wxMenu *) 0 ;
33014 wxMenuItem *result;
33015 PyObject * obj0 = 0 ;
33016 char *kwnames[] = {
33017 (char *) "self", NULL
33018 };
33019
33020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33022 if (SWIG_arg_fail(1)) SWIG_fail;
33023 {
33024 PyThreadState* __tstate = wxPyBeginAllowThreads();
33025 result = (wxMenuItem *)(arg1)->PrependSeparator();
33026
33027 wxPyEndAllowThreads(__tstate);
33028 if (PyErr_Occurred()) SWIG_fail;
33029 }
33030 {
33031 resultobj = wxPyMake_wxObject(result, 0);
33032 }
33033 return resultobj;
33034 fail:
33035 return NULL;
33036 }
33037
33038
33039 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33040 PyObject *resultobj;
33041 wxMenu *arg1 = (wxMenu *) 0 ;
33042 int arg2 ;
33043 wxString *arg3 = 0 ;
33044 wxString const &arg4_defvalue = wxPyEmptyString ;
33045 wxString *arg4 = (wxString *) &arg4_defvalue ;
33046 wxMenuItem *result;
33047 bool temp3 = false ;
33048 bool temp4 = false ;
33049 PyObject * obj0 = 0 ;
33050 PyObject * obj1 = 0 ;
33051 PyObject * obj2 = 0 ;
33052 PyObject * obj3 = 0 ;
33053 char *kwnames[] = {
33054 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33055 };
33056
33057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33059 if (SWIG_arg_fail(1)) SWIG_fail;
33060 {
33061 arg2 = (int)(SWIG_As_int(obj1));
33062 if (SWIG_arg_fail(2)) SWIG_fail;
33063 }
33064 {
33065 arg3 = wxString_in_helper(obj2);
33066 if (arg3 == NULL) SWIG_fail;
33067 temp3 = true;
33068 }
33069 if (obj3) {
33070 {
33071 arg4 = wxString_in_helper(obj3);
33072 if (arg4 == NULL) SWIG_fail;
33073 temp4 = true;
33074 }
33075 }
33076 {
33077 PyThreadState* __tstate = wxPyBeginAllowThreads();
33078 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33079
33080 wxPyEndAllowThreads(__tstate);
33081 if (PyErr_Occurred()) SWIG_fail;
33082 }
33083 {
33084 resultobj = wxPyMake_wxObject(result, 0);
33085 }
33086 {
33087 if (temp3)
33088 delete arg3;
33089 }
33090 {
33091 if (temp4)
33092 delete arg4;
33093 }
33094 return resultobj;
33095 fail:
33096 {
33097 if (temp3)
33098 delete arg3;
33099 }
33100 {
33101 if (temp4)
33102 delete arg4;
33103 }
33104 return NULL;
33105 }
33106
33107
33108 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33109 PyObject *resultobj;
33110 wxMenu *arg1 = (wxMenu *) 0 ;
33111 int arg2 ;
33112 wxString *arg3 = 0 ;
33113 wxString const &arg4_defvalue = wxPyEmptyString ;
33114 wxString *arg4 = (wxString *) &arg4_defvalue ;
33115 wxMenuItem *result;
33116 bool temp3 = false ;
33117 bool temp4 = false ;
33118 PyObject * obj0 = 0 ;
33119 PyObject * obj1 = 0 ;
33120 PyObject * obj2 = 0 ;
33121 PyObject * obj3 = 0 ;
33122 char *kwnames[] = {
33123 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33124 };
33125
33126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33128 if (SWIG_arg_fail(1)) SWIG_fail;
33129 {
33130 arg2 = (int)(SWIG_As_int(obj1));
33131 if (SWIG_arg_fail(2)) SWIG_fail;
33132 }
33133 {
33134 arg3 = wxString_in_helper(obj2);
33135 if (arg3 == NULL) SWIG_fail;
33136 temp3 = true;
33137 }
33138 if (obj3) {
33139 {
33140 arg4 = wxString_in_helper(obj3);
33141 if (arg4 == NULL) SWIG_fail;
33142 temp4 = true;
33143 }
33144 }
33145 {
33146 PyThreadState* __tstate = wxPyBeginAllowThreads();
33147 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33148
33149 wxPyEndAllowThreads(__tstate);
33150 if (PyErr_Occurred()) SWIG_fail;
33151 }
33152 {
33153 resultobj = wxPyMake_wxObject(result, 0);
33154 }
33155 {
33156 if (temp3)
33157 delete arg3;
33158 }
33159 {
33160 if (temp4)
33161 delete arg4;
33162 }
33163 return resultobj;
33164 fail:
33165 {
33166 if (temp3)
33167 delete arg3;
33168 }
33169 {
33170 if (temp4)
33171 delete arg4;
33172 }
33173 return NULL;
33174 }
33175
33176
33177 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33178 PyObject *resultobj;
33179 wxMenu *arg1 = (wxMenu *) 0 ;
33180 int arg2 ;
33181 wxString *arg3 = 0 ;
33182 wxMenu *arg4 = (wxMenu *) 0 ;
33183 wxString const &arg5_defvalue = wxPyEmptyString ;
33184 wxString *arg5 = (wxString *) &arg5_defvalue ;
33185 wxMenuItem *result;
33186 bool temp3 = false ;
33187 bool temp5 = false ;
33188 PyObject * obj0 = 0 ;
33189 PyObject * obj1 = 0 ;
33190 PyObject * obj2 = 0 ;
33191 PyObject * obj3 = 0 ;
33192 PyObject * obj4 = 0 ;
33193 char *kwnames[] = {
33194 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33195 };
33196
33197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33199 if (SWIG_arg_fail(1)) SWIG_fail;
33200 {
33201 arg2 = (int)(SWIG_As_int(obj1));
33202 if (SWIG_arg_fail(2)) SWIG_fail;
33203 }
33204 {
33205 arg3 = wxString_in_helper(obj2);
33206 if (arg3 == NULL) SWIG_fail;
33207 temp3 = true;
33208 }
33209 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33210 if (SWIG_arg_fail(4)) SWIG_fail;
33211 if (obj4) {
33212 {
33213 arg5 = wxString_in_helper(obj4);
33214 if (arg5 == NULL) SWIG_fail;
33215 temp5 = true;
33216 }
33217 }
33218 {
33219 PyThreadState* __tstate = wxPyBeginAllowThreads();
33220 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33221
33222 wxPyEndAllowThreads(__tstate);
33223 if (PyErr_Occurred()) SWIG_fail;
33224 }
33225 {
33226 resultobj = wxPyMake_wxObject(result, 0);
33227 }
33228 {
33229 if (temp3)
33230 delete arg3;
33231 }
33232 {
33233 if (temp5)
33234 delete arg5;
33235 }
33236 return resultobj;
33237 fail:
33238 {
33239 if (temp3)
33240 delete arg3;
33241 }
33242 {
33243 if (temp5)
33244 delete arg5;
33245 }
33246 return NULL;
33247 }
33248
33249
33250 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33251 PyObject *resultobj;
33252 wxMenu *arg1 = (wxMenu *) 0 ;
33253 int arg2 ;
33254 wxMenuItem *result;
33255 PyObject * obj0 = 0 ;
33256 PyObject * obj1 = 0 ;
33257 char *kwnames[] = {
33258 (char *) "self",(char *) "id", NULL
33259 };
33260
33261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33263 if (SWIG_arg_fail(1)) SWIG_fail;
33264 {
33265 arg2 = (int)(SWIG_As_int(obj1));
33266 if (SWIG_arg_fail(2)) SWIG_fail;
33267 }
33268 {
33269 PyThreadState* __tstate = wxPyBeginAllowThreads();
33270 result = (wxMenuItem *)(arg1)->Remove(arg2);
33271
33272 wxPyEndAllowThreads(__tstate);
33273 if (PyErr_Occurred()) SWIG_fail;
33274 }
33275 {
33276 resultobj = wxPyMake_wxObject(result, 0);
33277 }
33278 return resultobj;
33279 fail:
33280 return NULL;
33281 }
33282
33283
33284 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33285 PyObject *resultobj;
33286 wxMenu *arg1 = (wxMenu *) 0 ;
33287 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33288 wxMenuItem *result;
33289 PyObject * obj0 = 0 ;
33290 PyObject * obj1 = 0 ;
33291 char *kwnames[] = {
33292 (char *) "self",(char *) "item", NULL
33293 };
33294
33295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33297 if (SWIG_arg_fail(1)) SWIG_fail;
33298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33299 if (SWIG_arg_fail(2)) SWIG_fail;
33300 {
33301 PyThreadState* __tstate = wxPyBeginAllowThreads();
33302 result = (wxMenuItem *)(arg1)->Remove(arg2);
33303
33304 wxPyEndAllowThreads(__tstate);
33305 if (PyErr_Occurred()) SWIG_fail;
33306 }
33307 {
33308 resultobj = wxPyMake_wxObject(result, 0);
33309 }
33310 return resultobj;
33311 fail:
33312 return NULL;
33313 }
33314
33315
33316 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33317 PyObject *resultobj;
33318 wxMenu *arg1 = (wxMenu *) 0 ;
33319 int arg2 ;
33320 bool result;
33321 PyObject * obj0 = 0 ;
33322 PyObject * obj1 = 0 ;
33323 char *kwnames[] = {
33324 (char *) "self",(char *) "id", NULL
33325 };
33326
33327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33329 if (SWIG_arg_fail(1)) SWIG_fail;
33330 {
33331 arg2 = (int)(SWIG_As_int(obj1));
33332 if (SWIG_arg_fail(2)) SWIG_fail;
33333 }
33334 {
33335 PyThreadState* __tstate = wxPyBeginAllowThreads();
33336 result = (bool)(arg1)->Delete(arg2);
33337
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 {
33342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33343 }
33344 return resultobj;
33345 fail:
33346 return NULL;
33347 }
33348
33349
33350 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33351 PyObject *resultobj;
33352 wxMenu *arg1 = (wxMenu *) 0 ;
33353 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33354 bool result;
33355 PyObject * obj0 = 0 ;
33356 PyObject * obj1 = 0 ;
33357 char *kwnames[] = {
33358 (char *) "self",(char *) "item", NULL
33359 };
33360
33361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33363 if (SWIG_arg_fail(1)) SWIG_fail;
33364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33365 if (SWIG_arg_fail(2)) SWIG_fail;
33366 {
33367 PyThreadState* __tstate = wxPyBeginAllowThreads();
33368 result = (bool)(arg1)->Delete(arg2);
33369
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 {
33374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33375 }
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33383 PyObject *resultobj;
33384 wxMenu *arg1 = (wxMenu *) 0 ;
33385 PyObject * obj0 = 0 ;
33386 char *kwnames[] = {
33387 (char *) "self", NULL
33388 };
33389
33390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33392 if (SWIG_arg_fail(1)) SWIG_fail;
33393 {
33394 PyThreadState* __tstate = wxPyBeginAllowThreads();
33395 wxMenu_Destroy(arg1);
33396
33397 wxPyEndAllowThreads(__tstate);
33398 if (PyErr_Occurred()) SWIG_fail;
33399 }
33400 Py_INCREF(Py_None); resultobj = Py_None;
33401 return resultobj;
33402 fail:
33403 return NULL;
33404 }
33405
33406
33407 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33408 PyObject *resultobj;
33409 wxMenu *arg1 = (wxMenu *) 0 ;
33410 int arg2 ;
33411 bool result;
33412 PyObject * obj0 = 0 ;
33413 PyObject * obj1 = 0 ;
33414 char *kwnames[] = {
33415 (char *) "self",(char *) "id", NULL
33416 };
33417
33418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33420 if (SWIG_arg_fail(1)) SWIG_fail;
33421 {
33422 arg2 = (int)(SWIG_As_int(obj1));
33423 if (SWIG_arg_fail(2)) SWIG_fail;
33424 }
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 result = (bool)(arg1)->Destroy(arg2);
33428
33429 wxPyEndAllowThreads(__tstate);
33430 if (PyErr_Occurred()) SWIG_fail;
33431 }
33432 {
33433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33434 }
33435 return resultobj;
33436 fail:
33437 return NULL;
33438 }
33439
33440
33441 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33442 PyObject *resultobj;
33443 wxMenu *arg1 = (wxMenu *) 0 ;
33444 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33445 bool result;
33446 PyObject * obj0 = 0 ;
33447 PyObject * obj1 = 0 ;
33448 char *kwnames[] = {
33449 (char *) "self",(char *) "item", NULL
33450 };
33451
33452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33454 if (SWIG_arg_fail(1)) SWIG_fail;
33455 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33456 if (SWIG_arg_fail(2)) SWIG_fail;
33457 {
33458 PyThreadState* __tstate = wxPyBeginAllowThreads();
33459 result = (bool)(arg1)->Destroy(arg2);
33460
33461 wxPyEndAllowThreads(__tstate);
33462 if (PyErr_Occurred()) SWIG_fail;
33463 }
33464 {
33465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33466 }
33467 return resultobj;
33468 fail:
33469 return NULL;
33470 }
33471
33472
33473 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33474 PyObject *resultobj;
33475 wxMenu *arg1 = (wxMenu *) 0 ;
33476 size_t result;
33477 PyObject * obj0 = 0 ;
33478 char *kwnames[] = {
33479 (char *) "self", NULL
33480 };
33481
33482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33484 if (SWIG_arg_fail(1)) SWIG_fail;
33485 {
33486 PyThreadState* __tstate = wxPyBeginAllowThreads();
33487 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33488
33489 wxPyEndAllowThreads(__tstate);
33490 if (PyErr_Occurred()) SWIG_fail;
33491 }
33492 {
33493 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33494 }
33495 return resultobj;
33496 fail:
33497 return NULL;
33498 }
33499
33500
33501 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33502 PyObject *resultobj;
33503 wxMenu *arg1 = (wxMenu *) 0 ;
33504 PyObject *result;
33505 PyObject * obj0 = 0 ;
33506 char *kwnames[] = {
33507 (char *) "self", NULL
33508 };
33509
33510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33512 if (SWIG_arg_fail(1)) SWIG_fail;
33513 {
33514 PyThreadState* __tstate = wxPyBeginAllowThreads();
33515 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33516
33517 wxPyEndAllowThreads(__tstate);
33518 if (PyErr_Occurred()) SWIG_fail;
33519 }
33520 resultobj = result;
33521 return resultobj;
33522 fail:
33523 return NULL;
33524 }
33525
33526
33527 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33528 PyObject *resultobj;
33529 wxMenu *arg1 = (wxMenu *) 0 ;
33530 wxString *arg2 = 0 ;
33531 int result;
33532 bool temp2 = false ;
33533 PyObject * obj0 = 0 ;
33534 PyObject * obj1 = 0 ;
33535 char *kwnames[] = {
33536 (char *) "self",(char *) "item", NULL
33537 };
33538
33539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33541 if (SWIG_arg_fail(1)) SWIG_fail;
33542 {
33543 arg2 = wxString_in_helper(obj1);
33544 if (arg2 == NULL) SWIG_fail;
33545 temp2 = true;
33546 }
33547 {
33548 PyThreadState* __tstate = wxPyBeginAllowThreads();
33549 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33550
33551 wxPyEndAllowThreads(__tstate);
33552 if (PyErr_Occurred()) SWIG_fail;
33553 }
33554 {
33555 resultobj = SWIG_From_int((int)(result));
33556 }
33557 {
33558 if (temp2)
33559 delete arg2;
33560 }
33561 return resultobj;
33562 fail:
33563 {
33564 if (temp2)
33565 delete arg2;
33566 }
33567 return NULL;
33568 }
33569
33570
33571 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33572 PyObject *resultobj;
33573 wxMenu *arg1 = (wxMenu *) 0 ;
33574 int arg2 ;
33575 wxMenuItem *result;
33576 PyObject * obj0 = 0 ;
33577 PyObject * obj1 = 0 ;
33578 char *kwnames[] = {
33579 (char *) "self",(char *) "id", NULL
33580 };
33581
33582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33584 if (SWIG_arg_fail(1)) SWIG_fail;
33585 {
33586 arg2 = (int)(SWIG_As_int(obj1));
33587 if (SWIG_arg_fail(2)) SWIG_fail;
33588 }
33589 {
33590 PyThreadState* __tstate = wxPyBeginAllowThreads();
33591 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33592
33593 wxPyEndAllowThreads(__tstate);
33594 if (PyErr_Occurred()) SWIG_fail;
33595 }
33596 {
33597 resultobj = wxPyMake_wxObject(result, 0);
33598 }
33599 return resultobj;
33600 fail:
33601 return NULL;
33602 }
33603
33604
33605 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33606 PyObject *resultobj;
33607 wxMenu *arg1 = (wxMenu *) 0 ;
33608 size_t arg2 ;
33609 wxMenuItem *result;
33610 PyObject * obj0 = 0 ;
33611 PyObject * obj1 = 0 ;
33612 char *kwnames[] = {
33613 (char *) "self",(char *) "position", NULL
33614 };
33615
33616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33618 if (SWIG_arg_fail(1)) SWIG_fail;
33619 {
33620 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33621 if (SWIG_arg_fail(2)) SWIG_fail;
33622 }
33623 {
33624 PyThreadState* __tstate = wxPyBeginAllowThreads();
33625 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33626
33627 wxPyEndAllowThreads(__tstate);
33628 if (PyErr_Occurred()) SWIG_fail;
33629 }
33630 {
33631 resultobj = wxPyMake_wxObject(result, 0);
33632 }
33633 return resultobj;
33634 fail:
33635 return NULL;
33636 }
33637
33638
33639 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33640 PyObject *resultobj;
33641 wxMenu *arg1 = (wxMenu *) 0 ;
33642 int arg2 ;
33643 bool arg3 ;
33644 PyObject * obj0 = 0 ;
33645 PyObject * obj1 = 0 ;
33646 PyObject * obj2 = 0 ;
33647 char *kwnames[] = {
33648 (char *) "self",(char *) "id",(char *) "enable", NULL
33649 };
33650
33651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33653 if (SWIG_arg_fail(1)) SWIG_fail;
33654 {
33655 arg2 = (int)(SWIG_As_int(obj1));
33656 if (SWIG_arg_fail(2)) SWIG_fail;
33657 }
33658 {
33659 arg3 = (bool)(SWIG_As_bool(obj2));
33660 if (SWIG_arg_fail(3)) SWIG_fail;
33661 }
33662 {
33663 PyThreadState* __tstate = wxPyBeginAllowThreads();
33664 (arg1)->Enable(arg2,arg3);
33665
33666 wxPyEndAllowThreads(__tstate);
33667 if (PyErr_Occurred()) SWIG_fail;
33668 }
33669 Py_INCREF(Py_None); resultobj = Py_None;
33670 return resultobj;
33671 fail:
33672 return NULL;
33673 }
33674
33675
33676 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33677 PyObject *resultobj;
33678 wxMenu *arg1 = (wxMenu *) 0 ;
33679 int arg2 ;
33680 bool result;
33681 PyObject * obj0 = 0 ;
33682 PyObject * obj1 = 0 ;
33683 char *kwnames[] = {
33684 (char *) "self",(char *) "id", NULL
33685 };
33686
33687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33689 if (SWIG_arg_fail(1)) SWIG_fail;
33690 {
33691 arg2 = (int)(SWIG_As_int(obj1));
33692 if (SWIG_arg_fail(2)) SWIG_fail;
33693 }
33694 {
33695 PyThreadState* __tstate = wxPyBeginAllowThreads();
33696 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33697
33698 wxPyEndAllowThreads(__tstate);
33699 if (PyErr_Occurred()) SWIG_fail;
33700 }
33701 {
33702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33703 }
33704 return resultobj;
33705 fail:
33706 return NULL;
33707 }
33708
33709
33710 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33711 PyObject *resultobj;
33712 wxMenu *arg1 = (wxMenu *) 0 ;
33713 int arg2 ;
33714 bool arg3 ;
33715 PyObject * obj0 = 0 ;
33716 PyObject * obj1 = 0 ;
33717 PyObject * obj2 = 0 ;
33718 char *kwnames[] = {
33719 (char *) "self",(char *) "id",(char *) "check", NULL
33720 };
33721
33722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33724 if (SWIG_arg_fail(1)) SWIG_fail;
33725 {
33726 arg2 = (int)(SWIG_As_int(obj1));
33727 if (SWIG_arg_fail(2)) SWIG_fail;
33728 }
33729 {
33730 arg3 = (bool)(SWIG_As_bool(obj2));
33731 if (SWIG_arg_fail(3)) SWIG_fail;
33732 }
33733 {
33734 PyThreadState* __tstate = wxPyBeginAllowThreads();
33735 (arg1)->Check(arg2,arg3);
33736
33737 wxPyEndAllowThreads(__tstate);
33738 if (PyErr_Occurred()) SWIG_fail;
33739 }
33740 Py_INCREF(Py_None); resultobj = Py_None;
33741 return resultobj;
33742 fail:
33743 return NULL;
33744 }
33745
33746
33747 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33748 PyObject *resultobj;
33749 wxMenu *arg1 = (wxMenu *) 0 ;
33750 int arg2 ;
33751 bool result;
33752 PyObject * obj0 = 0 ;
33753 PyObject * obj1 = 0 ;
33754 char *kwnames[] = {
33755 (char *) "self",(char *) "id", NULL
33756 };
33757
33758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33760 if (SWIG_arg_fail(1)) SWIG_fail;
33761 {
33762 arg2 = (int)(SWIG_As_int(obj1));
33763 if (SWIG_arg_fail(2)) SWIG_fail;
33764 }
33765 {
33766 PyThreadState* __tstate = wxPyBeginAllowThreads();
33767 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33768
33769 wxPyEndAllowThreads(__tstate);
33770 if (PyErr_Occurred()) SWIG_fail;
33771 }
33772 {
33773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33774 }
33775 return resultobj;
33776 fail:
33777 return NULL;
33778 }
33779
33780
33781 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33782 PyObject *resultobj;
33783 wxMenu *arg1 = (wxMenu *) 0 ;
33784 int arg2 ;
33785 wxString *arg3 = 0 ;
33786 bool temp3 = false ;
33787 PyObject * obj0 = 0 ;
33788 PyObject * obj1 = 0 ;
33789 PyObject * obj2 = 0 ;
33790 char *kwnames[] = {
33791 (char *) "self",(char *) "id",(char *) "label", NULL
33792 };
33793
33794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33796 if (SWIG_arg_fail(1)) SWIG_fail;
33797 {
33798 arg2 = (int)(SWIG_As_int(obj1));
33799 if (SWIG_arg_fail(2)) SWIG_fail;
33800 }
33801 {
33802 arg3 = wxString_in_helper(obj2);
33803 if (arg3 == NULL) SWIG_fail;
33804 temp3 = true;
33805 }
33806 {
33807 PyThreadState* __tstate = wxPyBeginAllowThreads();
33808 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33809
33810 wxPyEndAllowThreads(__tstate);
33811 if (PyErr_Occurred()) SWIG_fail;
33812 }
33813 Py_INCREF(Py_None); resultobj = Py_None;
33814 {
33815 if (temp3)
33816 delete arg3;
33817 }
33818 return resultobj;
33819 fail:
33820 {
33821 if (temp3)
33822 delete arg3;
33823 }
33824 return NULL;
33825 }
33826
33827
33828 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33829 PyObject *resultobj;
33830 wxMenu *arg1 = (wxMenu *) 0 ;
33831 int arg2 ;
33832 wxString result;
33833 PyObject * obj0 = 0 ;
33834 PyObject * obj1 = 0 ;
33835 char *kwnames[] = {
33836 (char *) "self",(char *) "id", NULL
33837 };
33838
33839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33841 if (SWIG_arg_fail(1)) SWIG_fail;
33842 {
33843 arg2 = (int)(SWIG_As_int(obj1));
33844 if (SWIG_arg_fail(2)) SWIG_fail;
33845 }
33846 {
33847 PyThreadState* __tstate = wxPyBeginAllowThreads();
33848 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33849
33850 wxPyEndAllowThreads(__tstate);
33851 if (PyErr_Occurred()) SWIG_fail;
33852 }
33853 {
33854 #if wxUSE_UNICODE
33855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33856 #else
33857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33858 #endif
33859 }
33860 return resultobj;
33861 fail:
33862 return NULL;
33863 }
33864
33865
33866 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33867 PyObject *resultobj;
33868 wxMenu *arg1 = (wxMenu *) 0 ;
33869 int arg2 ;
33870 wxString *arg3 = 0 ;
33871 bool temp3 = false ;
33872 PyObject * obj0 = 0 ;
33873 PyObject * obj1 = 0 ;
33874 PyObject * obj2 = 0 ;
33875 char *kwnames[] = {
33876 (char *) "self",(char *) "id",(char *) "helpString", NULL
33877 };
33878
33879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33881 if (SWIG_arg_fail(1)) SWIG_fail;
33882 {
33883 arg2 = (int)(SWIG_As_int(obj1));
33884 if (SWIG_arg_fail(2)) SWIG_fail;
33885 }
33886 {
33887 arg3 = wxString_in_helper(obj2);
33888 if (arg3 == NULL) SWIG_fail;
33889 temp3 = true;
33890 }
33891 {
33892 PyThreadState* __tstate = wxPyBeginAllowThreads();
33893 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33894
33895 wxPyEndAllowThreads(__tstate);
33896 if (PyErr_Occurred()) SWIG_fail;
33897 }
33898 Py_INCREF(Py_None); resultobj = Py_None;
33899 {
33900 if (temp3)
33901 delete arg3;
33902 }
33903 return resultobj;
33904 fail:
33905 {
33906 if (temp3)
33907 delete arg3;
33908 }
33909 return NULL;
33910 }
33911
33912
33913 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33914 PyObject *resultobj;
33915 wxMenu *arg1 = (wxMenu *) 0 ;
33916 int arg2 ;
33917 wxString result;
33918 PyObject * obj0 = 0 ;
33919 PyObject * obj1 = 0 ;
33920 char *kwnames[] = {
33921 (char *) "self",(char *) "id", NULL
33922 };
33923
33924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33926 if (SWIG_arg_fail(1)) SWIG_fail;
33927 {
33928 arg2 = (int)(SWIG_As_int(obj1));
33929 if (SWIG_arg_fail(2)) SWIG_fail;
33930 }
33931 {
33932 PyThreadState* __tstate = wxPyBeginAllowThreads();
33933 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33934
33935 wxPyEndAllowThreads(__tstate);
33936 if (PyErr_Occurred()) SWIG_fail;
33937 }
33938 {
33939 #if wxUSE_UNICODE
33940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33941 #else
33942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33943 #endif
33944 }
33945 return resultobj;
33946 fail:
33947 return NULL;
33948 }
33949
33950
33951 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33952 PyObject *resultobj;
33953 wxMenu *arg1 = (wxMenu *) 0 ;
33954 wxString *arg2 = 0 ;
33955 bool temp2 = false ;
33956 PyObject * obj0 = 0 ;
33957 PyObject * obj1 = 0 ;
33958 char *kwnames[] = {
33959 (char *) "self",(char *) "title", NULL
33960 };
33961
33962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33964 if (SWIG_arg_fail(1)) SWIG_fail;
33965 {
33966 arg2 = wxString_in_helper(obj1);
33967 if (arg2 == NULL) SWIG_fail;
33968 temp2 = true;
33969 }
33970 {
33971 PyThreadState* __tstate = wxPyBeginAllowThreads();
33972 (arg1)->SetTitle((wxString const &)*arg2);
33973
33974 wxPyEndAllowThreads(__tstate);
33975 if (PyErr_Occurred()) SWIG_fail;
33976 }
33977 Py_INCREF(Py_None); resultobj = Py_None;
33978 {
33979 if (temp2)
33980 delete arg2;
33981 }
33982 return resultobj;
33983 fail:
33984 {
33985 if (temp2)
33986 delete arg2;
33987 }
33988 return NULL;
33989 }
33990
33991
33992 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33993 PyObject *resultobj;
33994 wxMenu *arg1 = (wxMenu *) 0 ;
33995 wxString result;
33996 PyObject * obj0 = 0 ;
33997 char *kwnames[] = {
33998 (char *) "self", NULL
33999 };
34000
34001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34003 if (SWIG_arg_fail(1)) SWIG_fail;
34004 {
34005 PyThreadState* __tstate = wxPyBeginAllowThreads();
34006 result = ((wxMenu const *)arg1)->GetTitle();
34007
34008 wxPyEndAllowThreads(__tstate);
34009 if (PyErr_Occurred()) SWIG_fail;
34010 }
34011 {
34012 #if wxUSE_UNICODE
34013 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34014 #else
34015 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34016 #endif
34017 }
34018 return resultobj;
34019 fail:
34020 return NULL;
34021 }
34022
34023
34024 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34025 PyObject *resultobj;
34026 wxMenu *arg1 = (wxMenu *) 0 ;
34027 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34028 PyObject * obj0 = 0 ;
34029 PyObject * obj1 = 0 ;
34030 char *kwnames[] = {
34031 (char *) "self",(char *) "handler", NULL
34032 };
34033
34034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34036 if (SWIG_arg_fail(1)) SWIG_fail;
34037 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34038 if (SWIG_arg_fail(2)) SWIG_fail;
34039 {
34040 PyThreadState* __tstate = wxPyBeginAllowThreads();
34041 (arg1)->SetEventHandler(arg2);
34042
34043 wxPyEndAllowThreads(__tstate);
34044 if (PyErr_Occurred()) SWIG_fail;
34045 }
34046 Py_INCREF(Py_None); resultobj = Py_None;
34047 return resultobj;
34048 fail:
34049 return NULL;
34050 }
34051
34052
34053 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34054 PyObject *resultobj;
34055 wxMenu *arg1 = (wxMenu *) 0 ;
34056 wxEvtHandler *result;
34057 PyObject * obj0 = 0 ;
34058 char *kwnames[] = {
34059 (char *) "self", NULL
34060 };
34061
34062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34064 if (SWIG_arg_fail(1)) SWIG_fail;
34065 {
34066 PyThreadState* __tstate = wxPyBeginAllowThreads();
34067 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34068
34069 wxPyEndAllowThreads(__tstate);
34070 if (PyErr_Occurred()) SWIG_fail;
34071 }
34072 {
34073 resultobj = wxPyMake_wxObject(result, 0);
34074 }
34075 return resultobj;
34076 fail:
34077 return NULL;
34078 }
34079
34080
34081 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34082 PyObject *resultobj;
34083 wxMenu *arg1 = (wxMenu *) 0 ;
34084 wxWindow *arg2 = (wxWindow *) 0 ;
34085 PyObject * obj0 = 0 ;
34086 PyObject * obj1 = 0 ;
34087 char *kwnames[] = {
34088 (char *) "self",(char *) "win", NULL
34089 };
34090
34091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34093 if (SWIG_arg_fail(1)) SWIG_fail;
34094 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34095 if (SWIG_arg_fail(2)) SWIG_fail;
34096 {
34097 PyThreadState* __tstate = wxPyBeginAllowThreads();
34098 (arg1)->SetInvokingWindow(arg2);
34099
34100 wxPyEndAllowThreads(__tstate);
34101 if (PyErr_Occurred()) SWIG_fail;
34102 }
34103 Py_INCREF(Py_None); resultobj = Py_None;
34104 return resultobj;
34105 fail:
34106 return NULL;
34107 }
34108
34109
34110 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34111 PyObject *resultobj;
34112 wxMenu *arg1 = (wxMenu *) 0 ;
34113 wxWindow *result;
34114 PyObject * obj0 = 0 ;
34115 char *kwnames[] = {
34116 (char *) "self", NULL
34117 };
34118
34119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34121 if (SWIG_arg_fail(1)) SWIG_fail;
34122 {
34123 PyThreadState* __tstate = wxPyBeginAllowThreads();
34124 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34125
34126 wxPyEndAllowThreads(__tstate);
34127 if (PyErr_Occurred()) SWIG_fail;
34128 }
34129 {
34130 resultobj = wxPyMake_wxObject(result, 0);
34131 }
34132 return resultobj;
34133 fail:
34134 return NULL;
34135 }
34136
34137
34138 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34139 PyObject *resultobj;
34140 wxMenu *arg1 = (wxMenu *) 0 ;
34141 long result;
34142 PyObject * obj0 = 0 ;
34143 char *kwnames[] = {
34144 (char *) "self", NULL
34145 };
34146
34147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34149 if (SWIG_arg_fail(1)) SWIG_fail;
34150 {
34151 PyThreadState* __tstate = wxPyBeginAllowThreads();
34152 result = (long)((wxMenu const *)arg1)->GetStyle();
34153
34154 wxPyEndAllowThreads(__tstate);
34155 if (PyErr_Occurred()) SWIG_fail;
34156 }
34157 {
34158 resultobj = SWIG_From_long((long)(result));
34159 }
34160 return resultobj;
34161 fail:
34162 return NULL;
34163 }
34164
34165
34166 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34167 PyObject *resultobj;
34168 wxMenu *arg1 = (wxMenu *) 0 ;
34169 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34170 PyObject * obj0 = 0 ;
34171 PyObject * obj1 = 0 ;
34172 char *kwnames[] = {
34173 (char *) "self",(char *) "source", NULL
34174 };
34175
34176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34178 if (SWIG_arg_fail(1)) SWIG_fail;
34179 if (obj1) {
34180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34181 if (SWIG_arg_fail(2)) SWIG_fail;
34182 }
34183 {
34184 PyThreadState* __tstate = wxPyBeginAllowThreads();
34185 (arg1)->UpdateUI(arg2);
34186
34187 wxPyEndAllowThreads(__tstate);
34188 if (PyErr_Occurred()) SWIG_fail;
34189 }
34190 Py_INCREF(Py_None); resultobj = Py_None;
34191 return resultobj;
34192 fail:
34193 return NULL;
34194 }
34195
34196
34197 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34198 PyObject *resultobj;
34199 wxMenu *arg1 = (wxMenu *) 0 ;
34200 wxMenuBar *result;
34201 PyObject * obj0 = 0 ;
34202 char *kwnames[] = {
34203 (char *) "self", NULL
34204 };
34205
34206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34208 if (SWIG_arg_fail(1)) SWIG_fail;
34209 {
34210 PyThreadState* __tstate = wxPyBeginAllowThreads();
34211 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34212
34213 wxPyEndAllowThreads(__tstate);
34214 if (PyErr_Occurred()) SWIG_fail;
34215 }
34216 {
34217 resultobj = wxPyMake_wxObject(result, 0);
34218 }
34219 return resultobj;
34220 fail:
34221 return NULL;
34222 }
34223
34224
34225 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34226 PyObject *resultobj;
34227 wxMenu *arg1 = (wxMenu *) 0 ;
34228 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34229 PyObject * obj0 = 0 ;
34230 PyObject * obj1 = 0 ;
34231 char *kwnames[] = {
34232 (char *) "self",(char *) "menubar", NULL
34233 };
34234
34235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34237 if (SWIG_arg_fail(1)) SWIG_fail;
34238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34239 if (SWIG_arg_fail(2)) SWIG_fail;
34240 {
34241 PyThreadState* __tstate = wxPyBeginAllowThreads();
34242 (arg1)->Attach(arg2);
34243
34244 wxPyEndAllowThreads(__tstate);
34245 if (PyErr_Occurred()) SWIG_fail;
34246 }
34247 Py_INCREF(Py_None); resultobj = Py_None;
34248 return resultobj;
34249 fail:
34250 return NULL;
34251 }
34252
34253
34254 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34255 PyObject *resultobj;
34256 wxMenu *arg1 = (wxMenu *) 0 ;
34257 PyObject * obj0 = 0 ;
34258 char *kwnames[] = {
34259 (char *) "self", NULL
34260 };
34261
34262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34264 if (SWIG_arg_fail(1)) SWIG_fail;
34265 {
34266 PyThreadState* __tstate = wxPyBeginAllowThreads();
34267 (arg1)->Detach();
34268
34269 wxPyEndAllowThreads(__tstate);
34270 if (PyErr_Occurred()) SWIG_fail;
34271 }
34272 Py_INCREF(Py_None); resultobj = Py_None;
34273 return resultobj;
34274 fail:
34275 return NULL;
34276 }
34277
34278
34279 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34280 PyObject *resultobj;
34281 wxMenu *arg1 = (wxMenu *) 0 ;
34282 bool result;
34283 PyObject * obj0 = 0 ;
34284 char *kwnames[] = {
34285 (char *) "self", NULL
34286 };
34287
34288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34290 if (SWIG_arg_fail(1)) SWIG_fail;
34291 {
34292 PyThreadState* __tstate = wxPyBeginAllowThreads();
34293 result = (bool)((wxMenu const *)arg1)->IsAttached();
34294
34295 wxPyEndAllowThreads(__tstate);
34296 if (PyErr_Occurred()) SWIG_fail;
34297 }
34298 {
34299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34300 }
34301 return resultobj;
34302 fail:
34303 return NULL;
34304 }
34305
34306
34307 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34308 PyObject *resultobj;
34309 wxMenu *arg1 = (wxMenu *) 0 ;
34310 wxMenu *arg2 = (wxMenu *) 0 ;
34311 PyObject * obj0 = 0 ;
34312 PyObject * obj1 = 0 ;
34313 char *kwnames[] = {
34314 (char *) "self",(char *) "parent", NULL
34315 };
34316
34317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34319 if (SWIG_arg_fail(1)) SWIG_fail;
34320 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34321 if (SWIG_arg_fail(2)) SWIG_fail;
34322 {
34323 PyThreadState* __tstate = wxPyBeginAllowThreads();
34324 (arg1)->SetParent(arg2);
34325
34326 wxPyEndAllowThreads(__tstate);
34327 if (PyErr_Occurred()) SWIG_fail;
34328 }
34329 Py_INCREF(Py_None); resultobj = Py_None;
34330 return resultobj;
34331 fail:
34332 return NULL;
34333 }
34334
34335
34336 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34337 PyObject *resultobj;
34338 wxMenu *arg1 = (wxMenu *) 0 ;
34339 wxMenu *result;
34340 PyObject * obj0 = 0 ;
34341 char *kwnames[] = {
34342 (char *) "self", NULL
34343 };
34344
34345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34347 if (SWIG_arg_fail(1)) SWIG_fail;
34348 {
34349 PyThreadState* __tstate = wxPyBeginAllowThreads();
34350 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34351
34352 wxPyEndAllowThreads(__tstate);
34353 if (PyErr_Occurred()) SWIG_fail;
34354 }
34355 {
34356 resultobj = wxPyMake_wxObject(result, 0);
34357 }
34358 return resultobj;
34359 fail:
34360 return NULL;
34361 }
34362
34363
34364 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34365 PyObject *obj;
34366 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34367 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34368 Py_INCREF(obj);
34369 return Py_BuildValue((char *)"");
34370 }
34371 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34372 PyObject *resultobj;
34373 long arg1 = (long) 0 ;
34374 wxMenuBar *result;
34375 PyObject * obj0 = 0 ;
34376 char *kwnames[] = {
34377 (char *) "style", NULL
34378 };
34379
34380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34381 if (obj0) {
34382 {
34383 arg1 = (long)(SWIG_As_long(obj0));
34384 if (SWIG_arg_fail(1)) SWIG_fail;
34385 }
34386 }
34387 {
34388 if (!wxPyCheckForApp()) SWIG_fail;
34389 PyThreadState* __tstate = wxPyBeginAllowThreads();
34390 result = (wxMenuBar *)new wxMenuBar(arg1);
34391
34392 wxPyEndAllowThreads(__tstate);
34393 if (PyErr_Occurred()) SWIG_fail;
34394 }
34395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34396 return resultobj;
34397 fail:
34398 return NULL;
34399 }
34400
34401
34402 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34403 PyObject *resultobj;
34404 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34405 wxMenu *arg2 = (wxMenu *) 0 ;
34406 wxString *arg3 = 0 ;
34407 bool result;
34408 bool temp3 = false ;
34409 PyObject * obj0 = 0 ;
34410 PyObject * obj1 = 0 ;
34411 PyObject * obj2 = 0 ;
34412 char *kwnames[] = {
34413 (char *) "self",(char *) "menu",(char *) "title", NULL
34414 };
34415
34416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34418 if (SWIG_arg_fail(1)) SWIG_fail;
34419 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34420 if (SWIG_arg_fail(2)) SWIG_fail;
34421 {
34422 arg3 = wxString_in_helper(obj2);
34423 if (arg3 == NULL) SWIG_fail;
34424 temp3 = true;
34425 }
34426 {
34427 PyThreadState* __tstate = wxPyBeginAllowThreads();
34428 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34429
34430 wxPyEndAllowThreads(__tstate);
34431 if (PyErr_Occurred()) SWIG_fail;
34432 }
34433 {
34434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34435 }
34436 {
34437 if (temp3)
34438 delete arg3;
34439 }
34440 return resultobj;
34441 fail:
34442 {
34443 if (temp3)
34444 delete arg3;
34445 }
34446 return NULL;
34447 }
34448
34449
34450 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34451 PyObject *resultobj;
34452 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34453 size_t arg2 ;
34454 wxMenu *arg3 = (wxMenu *) 0 ;
34455 wxString *arg4 = 0 ;
34456 bool result;
34457 bool temp4 = false ;
34458 PyObject * obj0 = 0 ;
34459 PyObject * obj1 = 0 ;
34460 PyObject * obj2 = 0 ;
34461 PyObject * obj3 = 0 ;
34462 char *kwnames[] = {
34463 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34464 };
34465
34466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34468 if (SWIG_arg_fail(1)) SWIG_fail;
34469 {
34470 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34471 if (SWIG_arg_fail(2)) SWIG_fail;
34472 }
34473 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34474 if (SWIG_arg_fail(3)) SWIG_fail;
34475 {
34476 arg4 = wxString_in_helper(obj3);
34477 if (arg4 == NULL) SWIG_fail;
34478 temp4 = true;
34479 }
34480 {
34481 PyThreadState* __tstate = wxPyBeginAllowThreads();
34482 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34483
34484 wxPyEndAllowThreads(__tstate);
34485 if (PyErr_Occurred()) SWIG_fail;
34486 }
34487 {
34488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34489 }
34490 {
34491 if (temp4)
34492 delete arg4;
34493 }
34494 return resultobj;
34495 fail:
34496 {
34497 if (temp4)
34498 delete arg4;
34499 }
34500 return NULL;
34501 }
34502
34503
34504 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34505 PyObject *resultobj;
34506 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34507 size_t result;
34508 PyObject * obj0 = 0 ;
34509 char *kwnames[] = {
34510 (char *) "self", NULL
34511 };
34512
34513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34515 if (SWIG_arg_fail(1)) SWIG_fail;
34516 {
34517 PyThreadState* __tstate = wxPyBeginAllowThreads();
34518 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34519
34520 wxPyEndAllowThreads(__tstate);
34521 if (PyErr_Occurred()) SWIG_fail;
34522 }
34523 {
34524 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34525 }
34526 return resultobj;
34527 fail:
34528 return NULL;
34529 }
34530
34531
34532 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34533 PyObject *resultobj;
34534 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34535 size_t arg2 ;
34536 wxMenu *result;
34537 PyObject * obj0 = 0 ;
34538 PyObject * obj1 = 0 ;
34539 char *kwnames[] = {
34540 (char *) "self",(char *) "pos", NULL
34541 };
34542
34543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34545 if (SWIG_arg_fail(1)) SWIG_fail;
34546 {
34547 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34548 if (SWIG_arg_fail(2)) SWIG_fail;
34549 }
34550 {
34551 PyThreadState* __tstate = wxPyBeginAllowThreads();
34552 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34553
34554 wxPyEndAllowThreads(__tstate);
34555 if (PyErr_Occurred()) SWIG_fail;
34556 }
34557 {
34558 resultobj = wxPyMake_wxObject(result, 0);
34559 }
34560 return resultobj;
34561 fail:
34562 return NULL;
34563 }
34564
34565
34566 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34567 PyObject *resultobj;
34568 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34569 size_t arg2 ;
34570 wxMenu *arg3 = (wxMenu *) 0 ;
34571 wxString *arg4 = 0 ;
34572 wxMenu *result;
34573 bool temp4 = false ;
34574 PyObject * obj0 = 0 ;
34575 PyObject * obj1 = 0 ;
34576 PyObject * obj2 = 0 ;
34577 PyObject * obj3 = 0 ;
34578 char *kwnames[] = {
34579 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34580 };
34581
34582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34584 if (SWIG_arg_fail(1)) SWIG_fail;
34585 {
34586 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34587 if (SWIG_arg_fail(2)) SWIG_fail;
34588 }
34589 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34590 if (SWIG_arg_fail(3)) SWIG_fail;
34591 {
34592 arg4 = wxString_in_helper(obj3);
34593 if (arg4 == NULL) SWIG_fail;
34594 temp4 = true;
34595 }
34596 {
34597 PyThreadState* __tstate = wxPyBeginAllowThreads();
34598 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34599
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 {
34604 resultobj = wxPyMake_wxObject(result, 0);
34605 }
34606 {
34607 if (temp4)
34608 delete arg4;
34609 }
34610 return resultobj;
34611 fail:
34612 {
34613 if (temp4)
34614 delete arg4;
34615 }
34616 return NULL;
34617 }
34618
34619
34620 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34621 PyObject *resultobj;
34622 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34623 size_t arg2 ;
34624 wxMenu *result;
34625 PyObject * obj0 = 0 ;
34626 PyObject * obj1 = 0 ;
34627 char *kwnames[] = {
34628 (char *) "self",(char *) "pos", NULL
34629 };
34630
34631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34633 if (SWIG_arg_fail(1)) SWIG_fail;
34634 {
34635 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34636 if (SWIG_arg_fail(2)) SWIG_fail;
34637 }
34638 {
34639 PyThreadState* __tstate = wxPyBeginAllowThreads();
34640 result = (wxMenu *)(arg1)->Remove(arg2);
34641
34642 wxPyEndAllowThreads(__tstate);
34643 if (PyErr_Occurred()) SWIG_fail;
34644 }
34645 {
34646 resultobj = wxPyMake_wxObject(result, 0);
34647 }
34648 return resultobj;
34649 fail:
34650 return NULL;
34651 }
34652
34653
34654 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34655 PyObject *resultobj;
34656 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34657 size_t arg2 ;
34658 bool arg3 ;
34659 PyObject * obj0 = 0 ;
34660 PyObject * obj1 = 0 ;
34661 PyObject * obj2 = 0 ;
34662 char *kwnames[] = {
34663 (char *) "self",(char *) "pos",(char *) "enable", NULL
34664 };
34665
34666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34668 if (SWIG_arg_fail(1)) SWIG_fail;
34669 {
34670 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34671 if (SWIG_arg_fail(2)) SWIG_fail;
34672 }
34673 {
34674 arg3 = (bool)(SWIG_As_bool(obj2));
34675 if (SWIG_arg_fail(3)) SWIG_fail;
34676 }
34677 {
34678 PyThreadState* __tstate = wxPyBeginAllowThreads();
34679 (arg1)->EnableTop(arg2,arg3);
34680
34681 wxPyEndAllowThreads(__tstate);
34682 if (PyErr_Occurred()) SWIG_fail;
34683 }
34684 Py_INCREF(Py_None); resultobj = Py_None;
34685 return resultobj;
34686 fail:
34687 return NULL;
34688 }
34689
34690
34691 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34692 PyObject *resultobj;
34693 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34694 size_t arg2 ;
34695 bool result;
34696 PyObject * obj0 = 0 ;
34697 PyObject * obj1 = 0 ;
34698 char *kwnames[] = {
34699 (char *) "self",(char *) "pos", NULL
34700 };
34701
34702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34704 if (SWIG_arg_fail(1)) SWIG_fail;
34705 {
34706 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34707 if (SWIG_arg_fail(2)) SWIG_fail;
34708 }
34709 {
34710 PyThreadState* __tstate = wxPyBeginAllowThreads();
34711 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34712
34713 wxPyEndAllowThreads(__tstate);
34714 if (PyErr_Occurred()) SWIG_fail;
34715 }
34716 {
34717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34718 }
34719 return resultobj;
34720 fail:
34721 return NULL;
34722 }
34723
34724
34725 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34726 PyObject *resultobj;
34727 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34728 size_t arg2 ;
34729 wxString *arg3 = 0 ;
34730 bool temp3 = false ;
34731 PyObject * obj0 = 0 ;
34732 PyObject * obj1 = 0 ;
34733 PyObject * obj2 = 0 ;
34734 char *kwnames[] = {
34735 (char *) "self",(char *) "pos",(char *) "label", NULL
34736 };
34737
34738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34740 if (SWIG_arg_fail(1)) SWIG_fail;
34741 {
34742 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34743 if (SWIG_arg_fail(2)) SWIG_fail;
34744 }
34745 {
34746 arg3 = wxString_in_helper(obj2);
34747 if (arg3 == NULL) SWIG_fail;
34748 temp3 = true;
34749 }
34750 {
34751 PyThreadState* __tstate = wxPyBeginAllowThreads();
34752 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34753
34754 wxPyEndAllowThreads(__tstate);
34755 if (PyErr_Occurred()) SWIG_fail;
34756 }
34757 Py_INCREF(Py_None); resultobj = Py_None;
34758 {
34759 if (temp3)
34760 delete arg3;
34761 }
34762 return resultobj;
34763 fail:
34764 {
34765 if (temp3)
34766 delete arg3;
34767 }
34768 return NULL;
34769 }
34770
34771
34772 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34773 PyObject *resultobj;
34774 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34775 size_t arg2 ;
34776 wxString result;
34777 PyObject * obj0 = 0 ;
34778 PyObject * obj1 = 0 ;
34779 char *kwnames[] = {
34780 (char *) "self",(char *) "pos", NULL
34781 };
34782
34783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34785 if (SWIG_arg_fail(1)) SWIG_fail;
34786 {
34787 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34788 if (SWIG_arg_fail(2)) SWIG_fail;
34789 }
34790 {
34791 PyThreadState* __tstate = wxPyBeginAllowThreads();
34792 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34793
34794 wxPyEndAllowThreads(__tstate);
34795 if (PyErr_Occurred()) SWIG_fail;
34796 }
34797 {
34798 #if wxUSE_UNICODE
34799 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34800 #else
34801 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34802 #endif
34803 }
34804 return resultobj;
34805 fail:
34806 return NULL;
34807 }
34808
34809
34810 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34811 PyObject *resultobj;
34812 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34813 wxString *arg2 = 0 ;
34814 wxString *arg3 = 0 ;
34815 int result;
34816 bool temp2 = false ;
34817 bool temp3 = false ;
34818 PyObject * obj0 = 0 ;
34819 PyObject * obj1 = 0 ;
34820 PyObject * obj2 = 0 ;
34821 char *kwnames[] = {
34822 (char *) "self",(char *) "menu",(char *) "item", NULL
34823 };
34824
34825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34827 if (SWIG_arg_fail(1)) SWIG_fail;
34828 {
34829 arg2 = wxString_in_helper(obj1);
34830 if (arg2 == NULL) SWIG_fail;
34831 temp2 = true;
34832 }
34833 {
34834 arg3 = wxString_in_helper(obj2);
34835 if (arg3 == NULL) SWIG_fail;
34836 temp3 = true;
34837 }
34838 {
34839 PyThreadState* __tstate = wxPyBeginAllowThreads();
34840 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34841
34842 wxPyEndAllowThreads(__tstate);
34843 if (PyErr_Occurred()) SWIG_fail;
34844 }
34845 {
34846 resultobj = SWIG_From_int((int)(result));
34847 }
34848 {
34849 if (temp2)
34850 delete arg2;
34851 }
34852 {
34853 if (temp3)
34854 delete arg3;
34855 }
34856 return resultobj;
34857 fail:
34858 {
34859 if (temp2)
34860 delete arg2;
34861 }
34862 {
34863 if (temp3)
34864 delete arg3;
34865 }
34866 return NULL;
34867 }
34868
34869
34870 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34871 PyObject *resultobj;
34872 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34873 int arg2 ;
34874 wxMenuItem *result;
34875 PyObject * obj0 = 0 ;
34876 PyObject * obj1 = 0 ;
34877 char *kwnames[] = {
34878 (char *) "self",(char *) "id", NULL
34879 };
34880
34881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34883 if (SWIG_arg_fail(1)) SWIG_fail;
34884 {
34885 arg2 = (int)(SWIG_As_int(obj1));
34886 if (SWIG_arg_fail(2)) SWIG_fail;
34887 }
34888 {
34889 PyThreadState* __tstate = wxPyBeginAllowThreads();
34890 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34891
34892 wxPyEndAllowThreads(__tstate);
34893 if (PyErr_Occurred()) SWIG_fail;
34894 }
34895 {
34896 resultobj = wxPyMake_wxObject(result, 0);
34897 }
34898 return resultobj;
34899 fail:
34900 return NULL;
34901 }
34902
34903
34904 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34905 PyObject *resultobj;
34906 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34907 wxString *arg2 = 0 ;
34908 int result;
34909 bool temp2 = false ;
34910 PyObject * obj0 = 0 ;
34911 PyObject * obj1 = 0 ;
34912 char *kwnames[] = {
34913 (char *) "self",(char *) "title", NULL
34914 };
34915
34916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34918 if (SWIG_arg_fail(1)) SWIG_fail;
34919 {
34920 arg2 = wxString_in_helper(obj1);
34921 if (arg2 == NULL) SWIG_fail;
34922 temp2 = true;
34923 }
34924 {
34925 PyThreadState* __tstate = wxPyBeginAllowThreads();
34926 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34927
34928 wxPyEndAllowThreads(__tstate);
34929 if (PyErr_Occurred()) SWIG_fail;
34930 }
34931 {
34932 resultobj = SWIG_From_int((int)(result));
34933 }
34934 {
34935 if (temp2)
34936 delete arg2;
34937 }
34938 return resultobj;
34939 fail:
34940 {
34941 if (temp2)
34942 delete arg2;
34943 }
34944 return NULL;
34945 }
34946
34947
34948 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34949 PyObject *resultobj;
34950 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34951 int arg2 ;
34952 bool arg3 ;
34953 PyObject * obj0 = 0 ;
34954 PyObject * obj1 = 0 ;
34955 PyObject * obj2 = 0 ;
34956 char *kwnames[] = {
34957 (char *) "self",(char *) "id",(char *) "enable", NULL
34958 };
34959
34960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34962 if (SWIG_arg_fail(1)) SWIG_fail;
34963 {
34964 arg2 = (int)(SWIG_As_int(obj1));
34965 if (SWIG_arg_fail(2)) SWIG_fail;
34966 }
34967 {
34968 arg3 = (bool)(SWIG_As_bool(obj2));
34969 if (SWIG_arg_fail(3)) SWIG_fail;
34970 }
34971 {
34972 PyThreadState* __tstate = wxPyBeginAllowThreads();
34973 (arg1)->Enable(arg2,arg3);
34974
34975 wxPyEndAllowThreads(__tstate);
34976 if (PyErr_Occurred()) SWIG_fail;
34977 }
34978 Py_INCREF(Py_None); resultobj = Py_None;
34979 return resultobj;
34980 fail:
34981 return NULL;
34982 }
34983
34984
34985 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34986 PyObject *resultobj;
34987 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34988 int arg2 ;
34989 bool arg3 ;
34990 PyObject * obj0 = 0 ;
34991 PyObject * obj1 = 0 ;
34992 PyObject * obj2 = 0 ;
34993 char *kwnames[] = {
34994 (char *) "self",(char *) "id",(char *) "check", NULL
34995 };
34996
34997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34999 if (SWIG_arg_fail(1)) SWIG_fail;
35000 {
35001 arg2 = (int)(SWIG_As_int(obj1));
35002 if (SWIG_arg_fail(2)) SWIG_fail;
35003 }
35004 {
35005 arg3 = (bool)(SWIG_As_bool(obj2));
35006 if (SWIG_arg_fail(3)) SWIG_fail;
35007 }
35008 {
35009 PyThreadState* __tstate = wxPyBeginAllowThreads();
35010 (arg1)->Check(arg2,arg3);
35011
35012 wxPyEndAllowThreads(__tstate);
35013 if (PyErr_Occurred()) SWIG_fail;
35014 }
35015 Py_INCREF(Py_None); resultobj = Py_None;
35016 return resultobj;
35017 fail:
35018 return NULL;
35019 }
35020
35021
35022 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35023 PyObject *resultobj;
35024 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35025 int arg2 ;
35026 bool result;
35027 PyObject * obj0 = 0 ;
35028 PyObject * obj1 = 0 ;
35029 char *kwnames[] = {
35030 (char *) "self",(char *) "id", NULL
35031 };
35032
35033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35035 if (SWIG_arg_fail(1)) SWIG_fail;
35036 {
35037 arg2 = (int)(SWIG_As_int(obj1));
35038 if (SWIG_arg_fail(2)) SWIG_fail;
35039 }
35040 {
35041 PyThreadState* __tstate = wxPyBeginAllowThreads();
35042 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35043
35044 wxPyEndAllowThreads(__tstate);
35045 if (PyErr_Occurred()) SWIG_fail;
35046 }
35047 {
35048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35049 }
35050 return resultobj;
35051 fail:
35052 return NULL;
35053 }
35054
35055
35056 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35057 PyObject *resultobj;
35058 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35059 int arg2 ;
35060 bool result;
35061 PyObject * obj0 = 0 ;
35062 PyObject * obj1 = 0 ;
35063 char *kwnames[] = {
35064 (char *) "self",(char *) "id", NULL
35065 };
35066
35067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35069 if (SWIG_arg_fail(1)) SWIG_fail;
35070 {
35071 arg2 = (int)(SWIG_As_int(obj1));
35072 if (SWIG_arg_fail(2)) SWIG_fail;
35073 }
35074 {
35075 PyThreadState* __tstate = wxPyBeginAllowThreads();
35076 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35077
35078 wxPyEndAllowThreads(__tstate);
35079 if (PyErr_Occurred()) SWIG_fail;
35080 }
35081 {
35082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35083 }
35084 return resultobj;
35085 fail:
35086 return NULL;
35087 }
35088
35089
35090 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35091 PyObject *resultobj;
35092 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35093 int arg2 ;
35094 wxString *arg3 = 0 ;
35095 bool temp3 = false ;
35096 PyObject * obj0 = 0 ;
35097 PyObject * obj1 = 0 ;
35098 PyObject * obj2 = 0 ;
35099 char *kwnames[] = {
35100 (char *) "self",(char *) "id",(char *) "label", NULL
35101 };
35102
35103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35105 if (SWIG_arg_fail(1)) SWIG_fail;
35106 {
35107 arg2 = (int)(SWIG_As_int(obj1));
35108 if (SWIG_arg_fail(2)) SWIG_fail;
35109 }
35110 {
35111 arg3 = wxString_in_helper(obj2);
35112 if (arg3 == NULL) SWIG_fail;
35113 temp3 = true;
35114 }
35115 {
35116 PyThreadState* __tstate = wxPyBeginAllowThreads();
35117 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35118
35119 wxPyEndAllowThreads(__tstate);
35120 if (PyErr_Occurred()) SWIG_fail;
35121 }
35122 Py_INCREF(Py_None); resultobj = Py_None;
35123 {
35124 if (temp3)
35125 delete arg3;
35126 }
35127 return resultobj;
35128 fail:
35129 {
35130 if (temp3)
35131 delete arg3;
35132 }
35133 return NULL;
35134 }
35135
35136
35137 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35138 PyObject *resultobj;
35139 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35140 int arg2 ;
35141 wxString result;
35142 PyObject * obj0 = 0 ;
35143 PyObject * obj1 = 0 ;
35144 char *kwnames[] = {
35145 (char *) "self",(char *) "id", NULL
35146 };
35147
35148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35150 if (SWIG_arg_fail(1)) SWIG_fail;
35151 {
35152 arg2 = (int)(SWIG_As_int(obj1));
35153 if (SWIG_arg_fail(2)) SWIG_fail;
35154 }
35155 {
35156 PyThreadState* __tstate = wxPyBeginAllowThreads();
35157 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35158
35159 wxPyEndAllowThreads(__tstate);
35160 if (PyErr_Occurred()) SWIG_fail;
35161 }
35162 {
35163 #if wxUSE_UNICODE
35164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35165 #else
35166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35167 #endif
35168 }
35169 return resultobj;
35170 fail:
35171 return NULL;
35172 }
35173
35174
35175 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35176 PyObject *resultobj;
35177 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35178 int arg2 ;
35179 wxString *arg3 = 0 ;
35180 bool temp3 = false ;
35181 PyObject * obj0 = 0 ;
35182 PyObject * obj1 = 0 ;
35183 PyObject * obj2 = 0 ;
35184 char *kwnames[] = {
35185 (char *) "self",(char *) "id",(char *) "helpString", NULL
35186 };
35187
35188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35190 if (SWIG_arg_fail(1)) SWIG_fail;
35191 {
35192 arg2 = (int)(SWIG_As_int(obj1));
35193 if (SWIG_arg_fail(2)) SWIG_fail;
35194 }
35195 {
35196 arg3 = wxString_in_helper(obj2);
35197 if (arg3 == NULL) SWIG_fail;
35198 temp3 = true;
35199 }
35200 {
35201 PyThreadState* __tstate = wxPyBeginAllowThreads();
35202 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35203
35204 wxPyEndAllowThreads(__tstate);
35205 if (PyErr_Occurred()) SWIG_fail;
35206 }
35207 Py_INCREF(Py_None); resultobj = Py_None;
35208 {
35209 if (temp3)
35210 delete arg3;
35211 }
35212 return resultobj;
35213 fail:
35214 {
35215 if (temp3)
35216 delete arg3;
35217 }
35218 return NULL;
35219 }
35220
35221
35222 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35223 PyObject *resultobj;
35224 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35225 int arg2 ;
35226 wxString result;
35227 PyObject * obj0 = 0 ;
35228 PyObject * obj1 = 0 ;
35229 char *kwnames[] = {
35230 (char *) "self",(char *) "id", NULL
35231 };
35232
35233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35235 if (SWIG_arg_fail(1)) SWIG_fail;
35236 {
35237 arg2 = (int)(SWIG_As_int(obj1));
35238 if (SWIG_arg_fail(2)) SWIG_fail;
35239 }
35240 {
35241 PyThreadState* __tstate = wxPyBeginAllowThreads();
35242 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35243
35244 wxPyEndAllowThreads(__tstate);
35245 if (PyErr_Occurred()) SWIG_fail;
35246 }
35247 {
35248 #if wxUSE_UNICODE
35249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35250 #else
35251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35252 #endif
35253 }
35254 return resultobj;
35255 fail:
35256 return NULL;
35257 }
35258
35259
35260 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35261 PyObject *resultobj;
35262 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35263 wxFrame *result;
35264 PyObject * obj0 = 0 ;
35265 char *kwnames[] = {
35266 (char *) "self", NULL
35267 };
35268
35269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35271 if (SWIG_arg_fail(1)) SWIG_fail;
35272 {
35273 PyThreadState* __tstate = wxPyBeginAllowThreads();
35274 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35275
35276 wxPyEndAllowThreads(__tstate);
35277 if (PyErr_Occurred()) SWIG_fail;
35278 }
35279 {
35280 resultobj = wxPyMake_wxObject(result, 0);
35281 }
35282 return resultobj;
35283 fail:
35284 return NULL;
35285 }
35286
35287
35288 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35289 PyObject *resultobj;
35290 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35291 bool result;
35292 PyObject * obj0 = 0 ;
35293 char *kwnames[] = {
35294 (char *) "self", NULL
35295 };
35296
35297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35299 if (SWIG_arg_fail(1)) SWIG_fail;
35300 {
35301 PyThreadState* __tstate = wxPyBeginAllowThreads();
35302 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35303
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 {
35308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35309 }
35310 return resultobj;
35311 fail:
35312 return NULL;
35313 }
35314
35315
35316 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35317 PyObject *resultobj;
35318 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35319 wxFrame *arg2 = (wxFrame *) 0 ;
35320 PyObject * obj0 = 0 ;
35321 PyObject * obj1 = 0 ;
35322 char *kwnames[] = {
35323 (char *) "self",(char *) "frame", NULL
35324 };
35325
35326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35328 if (SWIG_arg_fail(1)) SWIG_fail;
35329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35330 if (SWIG_arg_fail(2)) SWIG_fail;
35331 {
35332 PyThreadState* __tstate = wxPyBeginAllowThreads();
35333 (arg1)->Attach(arg2);
35334
35335 wxPyEndAllowThreads(__tstate);
35336 if (PyErr_Occurred()) SWIG_fail;
35337 }
35338 Py_INCREF(Py_None); resultobj = Py_None;
35339 return resultobj;
35340 fail:
35341 return NULL;
35342 }
35343
35344
35345 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35346 PyObject *resultobj;
35347 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35348 PyObject * obj0 = 0 ;
35349 char *kwnames[] = {
35350 (char *) "self", NULL
35351 };
35352
35353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35355 if (SWIG_arg_fail(1)) SWIG_fail;
35356 {
35357 PyThreadState* __tstate = wxPyBeginAllowThreads();
35358 (arg1)->Detach();
35359
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 Py_INCREF(Py_None); resultobj = Py_None;
35364 return resultobj;
35365 fail:
35366 return NULL;
35367 }
35368
35369
35370 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35371 PyObject *obj;
35372 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35373 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35374 Py_INCREF(obj);
35375 return Py_BuildValue((char *)"");
35376 }
35377 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35378 PyObject *resultobj;
35379 wxMenu *arg1 = (wxMenu *) NULL ;
35380 int arg2 = (int) wxID_ANY ;
35381 wxString const &arg3_defvalue = wxPyEmptyString ;
35382 wxString *arg3 = (wxString *) &arg3_defvalue ;
35383 wxString const &arg4_defvalue = wxPyEmptyString ;
35384 wxString *arg4 = (wxString *) &arg4_defvalue ;
35385 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35386 wxMenu *arg6 = (wxMenu *) NULL ;
35387 wxMenuItem *result;
35388 bool temp3 = false ;
35389 bool temp4 = false ;
35390 PyObject * obj0 = 0 ;
35391 PyObject * obj1 = 0 ;
35392 PyObject * obj2 = 0 ;
35393 PyObject * obj3 = 0 ;
35394 PyObject * obj4 = 0 ;
35395 PyObject * obj5 = 0 ;
35396 char *kwnames[] = {
35397 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35398 };
35399
35400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35401 if (obj0) {
35402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35403 if (SWIG_arg_fail(1)) SWIG_fail;
35404 }
35405 if (obj1) {
35406 {
35407 arg2 = (int)(SWIG_As_int(obj1));
35408 if (SWIG_arg_fail(2)) SWIG_fail;
35409 }
35410 }
35411 if (obj2) {
35412 {
35413 arg3 = wxString_in_helper(obj2);
35414 if (arg3 == NULL) SWIG_fail;
35415 temp3 = true;
35416 }
35417 }
35418 if (obj3) {
35419 {
35420 arg4 = wxString_in_helper(obj3);
35421 if (arg4 == NULL) SWIG_fail;
35422 temp4 = true;
35423 }
35424 }
35425 if (obj4) {
35426 {
35427 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35428 if (SWIG_arg_fail(5)) SWIG_fail;
35429 }
35430 }
35431 if (obj5) {
35432 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35433 if (SWIG_arg_fail(6)) SWIG_fail;
35434 }
35435 {
35436 PyThreadState* __tstate = wxPyBeginAllowThreads();
35437 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35438
35439 wxPyEndAllowThreads(__tstate);
35440 if (PyErr_Occurred()) SWIG_fail;
35441 }
35442 {
35443 resultobj = wxPyMake_wxObject(result, 1);
35444 }
35445 {
35446 if (temp3)
35447 delete arg3;
35448 }
35449 {
35450 if (temp4)
35451 delete arg4;
35452 }
35453 return resultobj;
35454 fail:
35455 {
35456 if (temp3)
35457 delete arg3;
35458 }
35459 {
35460 if (temp4)
35461 delete arg4;
35462 }
35463 return NULL;
35464 }
35465
35466
35467 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35468 PyObject *resultobj;
35469 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35470 wxMenu *result;
35471 PyObject * obj0 = 0 ;
35472 char *kwnames[] = {
35473 (char *) "self", NULL
35474 };
35475
35476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35478 if (SWIG_arg_fail(1)) SWIG_fail;
35479 {
35480 PyThreadState* __tstate = wxPyBeginAllowThreads();
35481 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35482
35483 wxPyEndAllowThreads(__tstate);
35484 if (PyErr_Occurred()) SWIG_fail;
35485 }
35486 {
35487 resultobj = wxPyMake_wxObject(result, 0);
35488 }
35489 return resultobj;
35490 fail:
35491 return NULL;
35492 }
35493
35494
35495 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35496 PyObject *resultobj;
35497 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35498 wxMenu *arg2 = (wxMenu *) 0 ;
35499 PyObject * obj0 = 0 ;
35500 PyObject * obj1 = 0 ;
35501 char *kwnames[] = {
35502 (char *) "self",(char *) "menu", NULL
35503 };
35504
35505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35507 if (SWIG_arg_fail(1)) SWIG_fail;
35508 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35509 if (SWIG_arg_fail(2)) SWIG_fail;
35510 {
35511 PyThreadState* __tstate = wxPyBeginAllowThreads();
35512 (arg1)->SetMenu(arg2);
35513
35514 wxPyEndAllowThreads(__tstate);
35515 if (PyErr_Occurred()) SWIG_fail;
35516 }
35517 Py_INCREF(Py_None); resultobj = Py_None;
35518 return resultobj;
35519 fail:
35520 return NULL;
35521 }
35522
35523
35524 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35525 PyObject *resultobj;
35526 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35527 int arg2 ;
35528 PyObject * obj0 = 0 ;
35529 PyObject * obj1 = 0 ;
35530 char *kwnames[] = {
35531 (char *) "self",(char *) "id", NULL
35532 };
35533
35534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35536 if (SWIG_arg_fail(1)) SWIG_fail;
35537 {
35538 arg2 = (int)(SWIG_As_int(obj1));
35539 if (SWIG_arg_fail(2)) SWIG_fail;
35540 }
35541 {
35542 PyThreadState* __tstate = wxPyBeginAllowThreads();
35543 (arg1)->SetId(arg2);
35544
35545 wxPyEndAllowThreads(__tstate);
35546 if (PyErr_Occurred()) SWIG_fail;
35547 }
35548 Py_INCREF(Py_None); resultobj = Py_None;
35549 return resultobj;
35550 fail:
35551 return NULL;
35552 }
35553
35554
35555 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35556 PyObject *resultobj;
35557 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35558 int result;
35559 PyObject * obj0 = 0 ;
35560 char *kwnames[] = {
35561 (char *) "self", NULL
35562 };
35563
35564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35566 if (SWIG_arg_fail(1)) SWIG_fail;
35567 {
35568 PyThreadState* __tstate = wxPyBeginAllowThreads();
35569 result = (int)((wxMenuItem const *)arg1)->GetId();
35570
35571 wxPyEndAllowThreads(__tstate);
35572 if (PyErr_Occurred()) SWIG_fail;
35573 }
35574 {
35575 resultobj = SWIG_From_int((int)(result));
35576 }
35577 return resultobj;
35578 fail:
35579 return NULL;
35580 }
35581
35582
35583 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35584 PyObject *resultobj;
35585 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35586 bool result;
35587 PyObject * obj0 = 0 ;
35588 char *kwnames[] = {
35589 (char *) "self", NULL
35590 };
35591
35592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35594 if (SWIG_arg_fail(1)) SWIG_fail;
35595 {
35596 PyThreadState* __tstate = wxPyBeginAllowThreads();
35597 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35598
35599 wxPyEndAllowThreads(__tstate);
35600 if (PyErr_Occurred()) SWIG_fail;
35601 }
35602 {
35603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35604 }
35605 return resultobj;
35606 fail:
35607 return NULL;
35608 }
35609
35610
35611 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35612 PyObject *resultobj;
35613 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35614 wxString *arg2 = 0 ;
35615 bool temp2 = false ;
35616 PyObject * obj0 = 0 ;
35617 PyObject * obj1 = 0 ;
35618 char *kwnames[] = {
35619 (char *) "self",(char *) "str", NULL
35620 };
35621
35622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35624 if (SWIG_arg_fail(1)) SWIG_fail;
35625 {
35626 arg2 = wxString_in_helper(obj1);
35627 if (arg2 == NULL) SWIG_fail;
35628 temp2 = true;
35629 }
35630 {
35631 PyThreadState* __tstate = wxPyBeginAllowThreads();
35632 (arg1)->SetText((wxString const &)*arg2);
35633
35634 wxPyEndAllowThreads(__tstate);
35635 if (PyErr_Occurred()) SWIG_fail;
35636 }
35637 Py_INCREF(Py_None); resultobj = Py_None;
35638 {
35639 if (temp2)
35640 delete arg2;
35641 }
35642 return resultobj;
35643 fail:
35644 {
35645 if (temp2)
35646 delete arg2;
35647 }
35648 return NULL;
35649 }
35650
35651
35652 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35653 PyObject *resultobj;
35654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35655 wxString result;
35656 PyObject * obj0 = 0 ;
35657 char *kwnames[] = {
35658 (char *) "self", NULL
35659 };
35660
35661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35663 if (SWIG_arg_fail(1)) SWIG_fail;
35664 {
35665 PyThreadState* __tstate = wxPyBeginAllowThreads();
35666 result = ((wxMenuItem const *)arg1)->GetLabel();
35667
35668 wxPyEndAllowThreads(__tstate);
35669 if (PyErr_Occurred()) SWIG_fail;
35670 }
35671 {
35672 #if wxUSE_UNICODE
35673 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35674 #else
35675 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35676 #endif
35677 }
35678 return resultobj;
35679 fail:
35680 return NULL;
35681 }
35682
35683
35684 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35685 PyObject *resultobj;
35686 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35687 wxString *result;
35688 PyObject * obj0 = 0 ;
35689 char *kwnames[] = {
35690 (char *) "self", NULL
35691 };
35692
35693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35695 if (SWIG_arg_fail(1)) SWIG_fail;
35696 {
35697 PyThreadState* __tstate = wxPyBeginAllowThreads();
35698 {
35699 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35700 result = (wxString *) &_result_ref;
35701 }
35702
35703 wxPyEndAllowThreads(__tstate);
35704 if (PyErr_Occurred()) SWIG_fail;
35705 }
35706 {
35707 #if wxUSE_UNICODE
35708 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35709 #else
35710 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35711 #endif
35712 }
35713 return resultobj;
35714 fail:
35715 return NULL;
35716 }
35717
35718
35719 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35720 PyObject *resultobj;
35721 wxString *arg1 = 0 ;
35722 wxString result;
35723 bool temp1 = false ;
35724 PyObject * obj0 = 0 ;
35725 char *kwnames[] = {
35726 (char *) "text", NULL
35727 };
35728
35729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35730 {
35731 arg1 = wxString_in_helper(obj0);
35732 if (arg1 == NULL) SWIG_fail;
35733 temp1 = true;
35734 }
35735 {
35736 PyThreadState* __tstate = wxPyBeginAllowThreads();
35737 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35738
35739 wxPyEndAllowThreads(__tstate);
35740 if (PyErr_Occurred()) SWIG_fail;
35741 }
35742 {
35743 #if wxUSE_UNICODE
35744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35745 #else
35746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35747 #endif
35748 }
35749 {
35750 if (temp1)
35751 delete arg1;
35752 }
35753 return resultobj;
35754 fail:
35755 {
35756 if (temp1)
35757 delete arg1;
35758 }
35759 return NULL;
35760 }
35761
35762
35763 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35764 PyObject *resultobj;
35765 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35766 wxItemKind result;
35767 PyObject * obj0 = 0 ;
35768 char *kwnames[] = {
35769 (char *) "self", NULL
35770 };
35771
35772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35774 if (SWIG_arg_fail(1)) SWIG_fail;
35775 {
35776 PyThreadState* __tstate = wxPyBeginAllowThreads();
35777 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35778
35779 wxPyEndAllowThreads(__tstate);
35780 if (PyErr_Occurred()) SWIG_fail;
35781 }
35782 resultobj = SWIG_From_int((result));
35783 return resultobj;
35784 fail:
35785 return NULL;
35786 }
35787
35788
35789 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35790 PyObject *resultobj;
35791 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35792 wxItemKind arg2 ;
35793 PyObject * obj0 = 0 ;
35794 PyObject * obj1 = 0 ;
35795 char *kwnames[] = {
35796 (char *) "self",(char *) "kind", NULL
35797 };
35798
35799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35801 if (SWIG_arg_fail(1)) SWIG_fail;
35802 {
35803 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35804 if (SWIG_arg_fail(2)) SWIG_fail;
35805 }
35806 {
35807 PyThreadState* __tstate = wxPyBeginAllowThreads();
35808 (arg1)->SetKind((wxItemKind )arg2);
35809
35810 wxPyEndAllowThreads(__tstate);
35811 if (PyErr_Occurred()) SWIG_fail;
35812 }
35813 Py_INCREF(Py_None); resultobj = Py_None;
35814 return resultobj;
35815 fail:
35816 return NULL;
35817 }
35818
35819
35820 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35821 PyObject *resultobj;
35822 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35823 bool arg2 ;
35824 PyObject * obj0 = 0 ;
35825 PyObject * obj1 = 0 ;
35826 char *kwnames[] = {
35827 (char *) "self",(char *) "checkable", NULL
35828 };
35829
35830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35832 if (SWIG_arg_fail(1)) SWIG_fail;
35833 {
35834 arg2 = (bool)(SWIG_As_bool(obj1));
35835 if (SWIG_arg_fail(2)) SWIG_fail;
35836 }
35837 {
35838 PyThreadState* __tstate = wxPyBeginAllowThreads();
35839 (arg1)->SetCheckable(arg2);
35840
35841 wxPyEndAllowThreads(__tstate);
35842 if (PyErr_Occurred()) SWIG_fail;
35843 }
35844 Py_INCREF(Py_None); resultobj = Py_None;
35845 return resultobj;
35846 fail:
35847 return NULL;
35848 }
35849
35850
35851 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35852 PyObject *resultobj;
35853 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35854 bool result;
35855 PyObject * obj0 = 0 ;
35856 char *kwnames[] = {
35857 (char *) "self", NULL
35858 };
35859
35860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35862 if (SWIG_arg_fail(1)) SWIG_fail;
35863 {
35864 PyThreadState* __tstate = wxPyBeginAllowThreads();
35865 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35866
35867 wxPyEndAllowThreads(__tstate);
35868 if (PyErr_Occurred()) SWIG_fail;
35869 }
35870 {
35871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35872 }
35873 return resultobj;
35874 fail:
35875 return NULL;
35876 }
35877
35878
35879 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35880 PyObject *resultobj;
35881 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35882 bool result;
35883 PyObject * obj0 = 0 ;
35884 char *kwnames[] = {
35885 (char *) "self", NULL
35886 };
35887
35888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35890 if (SWIG_arg_fail(1)) SWIG_fail;
35891 {
35892 PyThreadState* __tstate = wxPyBeginAllowThreads();
35893 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35894
35895 wxPyEndAllowThreads(__tstate);
35896 if (PyErr_Occurred()) SWIG_fail;
35897 }
35898 {
35899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35900 }
35901 return resultobj;
35902 fail:
35903 return NULL;
35904 }
35905
35906
35907 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35908 PyObject *resultobj;
35909 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35910 wxMenu *arg2 = (wxMenu *) 0 ;
35911 PyObject * obj0 = 0 ;
35912 PyObject * obj1 = 0 ;
35913 char *kwnames[] = {
35914 (char *) "self",(char *) "menu", NULL
35915 };
35916
35917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35919 if (SWIG_arg_fail(1)) SWIG_fail;
35920 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35921 if (SWIG_arg_fail(2)) SWIG_fail;
35922 {
35923 PyThreadState* __tstate = wxPyBeginAllowThreads();
35924 (arg1)->SetSubMenu(arg2);
35925
35926 wxPyEndAllowThreads(__tstate);
35927 if (PyErr_Occurred()) SWIG_fail;
35928 }
35929 Py_INCREF(Py_None); resultobj = Py_None;
35930 return resultobj;
35931 fail:
35932 return NULL;
35933 }
35934
35935
35936 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35937 PyObject *resultobj;
35938 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35939 wxMenu *result;
35940 PyObject * obj0 = 0 ;
35941 char *kwnames[] = {
35942 (char *) "self", NULL
35943 };
35944
35945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35947 if (SWIG_arg_fail(1)) SWIG_fail;
35948 {
35949 PyThreadState* __tstate = wxPyBeginAllowThreads();
35950 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35951
35952 wxPyEndAllowThreads(__tstate);
35953 if (PyErr_Occurred()) SWIG_fail;
35954 }
35955 {
35956 resultobj = wxPyMake_wxObject(result, 0);
35957 }
35958 return resultobj;
35959 fail:
35960 return NULL;
35961 }
35962
35963
35964 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35965 PyObject *resultobj;
35966 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35967 bool arg2 = (bool) true ;
35968 PyObject * obj0 = 0 ;
35969 PyObject * obj1 = 0 ;
35970 char *kwnames[] = {
35971 (char *) "self",(char *) "enable", NULL
35972 };
35973
35974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35976 if (SWIG_arg_fail(1)) SWIG_fail;
35977 if (obj1) {
35978 {
35979 arg2 = (bool)(SWIG_As_bool(obj1));
35980 if (SWIG_arg_fail(2)) SWIG_fail;
35981 }
35982 }
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 (arg1)->Enable(arg2);
35986
35987 wxPyEndAllowThreads(__tstate);
35988 if (PyErr_Occurred()) SWIG_fail;
35989 }
35990 Py_INCREF(Py_None); resultobj = Py_None;
35991 return resultobj;
35992 fail:
35993 return NULL;
35994 }
35995
35996
35997 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35998 PyObject *resultobj;
35999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36000 bool result;
36001 PyObject * obj0 = 0 ;
36002 char *kwnames[] = {
36003 (char *) "self", NULL
36004 };
36005
36006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36008 if (SWIG_arg_fail(1)) SWIG_fail;
36009 {
36010 PyThreadState* __tstate = wxPyBeginAllowThreads();
36011 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36012
36013 wxPyEndAllowThreads(__tstate);
36014 if (PyErr_Occurred()) SWIG_fail;
36015 }
36016 {
36017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36018 }
36019 return resultobj;
36020 fail:
36021 return NULL;
36022 }
36023
36024
36025 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36026 PyObject *resultobj;
36027 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36028 bool arg2 = (bool) true ;
36029 PyObject * obj0 = 0 ;
36030 PyObject * obj1 = 0 ;
36031 char *kwnames[] = {
36032 (char *) "self",(char *) "check", NULL
36033 };
36034
36035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36037 if (SWIG_arg_fail(1)) SWIG_fail;
36038 if (obj1) {
36039 {
36040 arg2 = (bool)(SWIG_As_bool(obj1));
36041 if (SWIG_arg_fail(2)) SWIG_fail;
36042 }
36043 }
36044 {
36045 PyThreadState* __tstate = wxPyBeginAllowThreads();
36046 (arg1)->Check(arg2);
36047
36048 wxPyEndAllowThreads(__tstate);
36049 if (PyErr_Occurred()) SWIG_fail;
36050 }
36051 Py_INCREF(Py_None); resultobj = Py_None;
36052 return resultobj;
36053 fail:
36054 return NULL;
36055 }
36056
36057
36058 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36059 PyObject *resultobj;
36060 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36061 bool result;
36062 PyObject * obj0 = 0 ;
36063 char *kwnames[] = {
36064 (char *) "self", NULL
36065 };
36066
36067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36069 if (SWIG_arg_fail(1)) SWIG_fail;
36070 {
36071 PyThreadState* __tstate = wxPyBeginAllowThreads();
36072 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36073
36074 wxPyEndAllowThreads(__tstate);
36075 if (PyErr_Occurred()) SWIG_fail;
36076 }
36077 {
36078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36079 }
36080 return resultobj;
36081 fail:
36082 return NULL;
36083 }
36084
36085
36086 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36087 PyObject *resultobj;
36088 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36089 PyObject * obj0 = 0 ;
36090 char *kwnames[] = {
36091 (char *) "self", NULL
36092 };
36093
36094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36096 if (SWIG_arg_fail(1)) SWIG_fail;
36097 {
36098 PyThreadState* __tstate = wxPyBeginAllowThreads();
36099 (arg1)->Toggle();
36100
36101 wxPyEndAllowThreads(__tstate);
36102 if (PyErr_Occurred()) SWIG_fail;
36103 }
36104 Py_INCREF(Py_None); resultobj = Py_None;
36105 return resultobj;
36106 fail:
36107 return NULL;
36108 }
36109
36110
36111 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36112 PyObject *resultobj;
36113 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36114 wxString *arg2 = 0 ;
36115 bool temp2 = false ;
36116 PyObject * obj0 = 0 ;
36117 PyObject * obj1 = 0 ;
36118 char *kwnames[] = {
36119 (char *) "self",(char *) "str", NULL
36120 };
36121
36122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36124 if (SWIG_arg_fail(1)) SWIG_fail;
36125 {
36126 arg2 = wxString_in_helper(obj1);
36127 if (arg2 == NULL) SWIG_fail;
36128 temp2 = true;
36129 }
36130 {
36131 PyThreadState* __tstate = wxPyBeginAllowThreads();
36132 (arg1)->SetHelp((wxString const &)*arg2);
36133
36134 wxPyEndAllowThreads(__tstate);
36135 if (PyErr_Occurred()) SWIG_fail;
36136 }
36137 Py_INCREF(Py_None); resultobj = Py_None;
36138 {
36139 if (temp2)
36140 delete arg2;
36141 }
36142 return resultobj;
36143 fail:
36144 {
36145 if (temp2)
36146 delete arg2;
36147 }
36148 return NULL;
36149 }
36150
36151
36152 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36153 PyObject *resultobj;
36154 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36155 wxString *result;
36156 PyObject * obj0 = 0 ;
36157 char *kwnames[] = {
36158 (char *) "self", NULL
36159 };
36160
36161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36163 if (SWIG_arg_fail(1)) SWIG_fail;
36164 {
36165 PyThreadState* __tstate = wxPyBeginAllowThreads();
36166 {
36167 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36168 result = (wxString *) &_result_ref;
36169 }
36170
36171 wxPyEndAllowThreads(__tstate);
36172 if (PyErr_Occurred()) SWIG_fail;
36173 }
36174 {
36175 #if wxUSE_UNICODE
36176 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36177 #else
36178 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36179 #endif
36180 }
36181 return resultobj;
36182 fail:
36183 return NULL;
36184 }
36185
36186
36187 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36188 PyObject *resultobj;
36189 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36190 wxAcceleratorEntry *result;
36191 PyObject * obj0 = 0 ;
36192 char *kwnames[] = {
36193 (char *) "self", NULL
36194 };
36195
36196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36198 if (SWIG_arg_fail(1)) SWIG_fail;
36199 {
36200 PyThreadState* __tstate = wxPyBeginAllowThreads();
36201 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36202
36203 wxPyEndAllowThreads(__tstate);
36204 if (PyErr_Occurred()) SWIG_fail;
36205 }
36206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36207 return resultobj;
36208 fail:
36209 return NULL;
36210 }
36211
36212
36213 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36214 PyObject *resultobj;
36215 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36216 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36217 PyObject * obj0 = 0 ;
36218 PyObject * obj1 = 0 ;
36219 char *kwnames[] = {
36220 (char *) "self",(char *) "accel", NULL
36221 };
36222
36223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36225 if (SWIG_arg_fail(1)) SWIG_fail;
36226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36227 if (SWIG_arg_fail(2)) SWIG_fail;
36228 {
36229 PyThreadState* __tstate = wxPyBeginAllowThreads();
36230 (arg1)->SetAccel(arg2);
36231
36232 wxPyEndAllowThreads(__tstate);
36233 if (PyErr_Occurred()) SWIG_fail;
36234 }
36235 Py_INCREF(Py_None); resultobj = Py_None;
36236 return resultobj;
36237 fail:
36238 return NULL;
36239 }
36240
36241
36242 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36243 PyObject *resultobj;
36244 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36245 wxFont *arg2 = 0 ;
36246 PyObject * obj0 = 0 ;
36247 PyObject * obj1 = 0 ;
36248 char *kwnames[] = {
36249 (char *) "self",(char *) "font", NULL
36250 };
36251
36252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36254 if (SWIG_arg_fail(1)) SWIG_fail;
36255 {
36256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36257 if (SWIG_arg_fail(2)) SWIG_fail;
36258 if (arg2 == NULL) {
36259 SWIG_null_ref("wxFont");
36260 }
36261 if (SWIG_arg_fail(2)) SWIG_fail;
36262 }
36263 {
36264 PyThreadState* __tstate = wxPyBeginAllowThreads();
36265 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36266
36267 wxPyEndAllowThreads(__tstate);
36268 if (PyErr_Occurred()) SWIG_fail;
36269 }
36270 Py_INCREF(Py_None); resultobj = Py_None;
36271 return resultobj;
36272 fail:
36273 return NULL;
36274 }
36275
36276
36277 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36278 PyObject *resultobj;
36279 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36280 wxFont result;
36281 PyObject * obj0 = 0 ;
36282 char *kwnames[] = {
36283 (char *) "self", NULL
36284 };
36285
36286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36288 if (SWIG_arg_fail(1)) SWIG_fail;
36289 {
36290 PyThreadState* __tstate = wxPyBeginAllowThreads();
36291 result = wxMenuItem_GetFont(arg1);
36292
36293 wxPyEndAllowThreads(__tstate);
36294 if (PyErr_Occurred()) SWIG_fail;
36295 }
36296 {
36297 wxFont * resultptr;
36298 resultptr = new wxFont((wxFont &)(result));
36299 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36300 }
36301 return resultobj;
36302 fail:
36303 return NULL;
36304 }
36305
36306
36307 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36308 PyObject *resultobj;
36309 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36310 wxColour *arg2 = 0 ;
36311 wxColour temp2 ;
36312 PyObject * obj0 = 0 ;
36313 PyObject * obj1 = 0 ;
36314 char *kwnames[] = {
36315 (char *) "self",(char *) "colText", NULL
36316 };
36317
36318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36320 if (SWIG_arg_fail(1)) SWIG_fail;
36321 {
36322 arg2 = &temp2;
36323 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36324 }
36325 {
36326 PyThreadState* __tstate = wxPyBeginAllowThreads();
36327 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36328
36329 wxPyEndAllowThreads(__tstate);
36330 if (PyErr_Occurred()) SWIG_fail;
36331 }
36332 Py_INCREF(Py_None); resultobj = Py_None;
36333 return resultobj;
36334 fail:
36335 return NULL;
36336 }
36337
36338
36339 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36340 PyObject *resultobj;
36341 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36342 wxColour result;
36343 PyObject * obj0 = 0 ;
36344 char *kwnames[] = {
36345 (char *) "self", NULL
36346 };
36347
36348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36350 if (SWIG_arg_fail(1)) SWIG_fail;
36351 {
36352 PyThreadState* __tstate = wxPyBeginAllowThreads();
36353 result = wxMenuItem_GetTextColour(arg1);
36354
36355 wxPyEndAllowThreads(__tstate);
36356 if (PyErr_Occurred()) SWIG_fail;
36357 }
36358 {
36359 wxColour * resultptr;
36360 resultptr = new wxColour((wxColour &)(result));
36361 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36362 }
36363 return resultobj;
36364 fail:
36365 return NULL;
36366 }
36367
36368
36369 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36370 PyObject *resultobj;
36371 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36372 wxColour *arg2 = 0 ;
36373 wxColour temp2 ;
36374 PyObject * obj0 = 0 ;
36375 PyObject * obj1 = 0 ;
36376 char *kwnames[] = {
36377 (char *) "self",(char *) "colBack", NULL
36378 };
36379
36380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36382 if (SWIG_arg_fail(1)) SWIG_fail;
36383 {
36384 arg2 = &temp2;
36385 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36386 }
36387 {
36388 PyThreadState* __tstate = wxPyBeginAllowThreads();
36389 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36390
36391 wxPyEndAllowThreads(__tstate);
36392 if (PyErr_Occurred()) SWIG_fail;
36393 }
36394 Py_INCREF(Py_None); resultobj = Py_None;
36395 return resultobj;
36396 fail:
36397 return NULL;
36398 }
36399
36400
36401 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36402 PyObject *resultobj;
36403 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36404 wxColour result;
36405 PyObject * obj0 = 0 ;
36406 char *kwnames[] = {
36407 (char *) "self", NULL
36408 };
36409
36410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36412 if (SWIG_arg_fail(1)) SWIG_fail;
36413 {
36414 PyThreadState* __tstate = wxPyBeginAllowThreads();
36415 result = wxMenuItem_GetBackgroundColour(arg1);
36416
36417 wxPyEndAllowThreads(__tstate);
36418 if (PyErr_Occurred()) SWIG_fail;
36419 }
36420 {
36421 wxColour * resultptr;
36422 resultptr = new wxColour((wxColour &)(result));
36423 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36424 }
36425 return resultobj;
36426 fail:
36427 return NULL;
36428 }
36429
36430
36431 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36432 PyObject *resultobj;
36433 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36434 wxBitmap *arg2 = 0 ;
36435 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36436 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36437 PyObject * obj0 = 0 ;
36438 PyObject * obj1 = 0 ;
36439 PyObject * obj2 = 0 ;
36440 char *kwnames[] = {
36441 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36442 };
36443
36444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36446 if (SWIG_arg_fail(1)) SWIG_fail;
36447 {
36448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36449 if (SWIG_arg_fail(2)) SWIG_fail;
36450 if (arg2 == NULL) {
36451 SWIG_null_ref("wxBitmap");
36452 }
36453 if (SWIG_arg_fail(2)) SWIG_fail;
36454 }
36455 if (obj2) {
36456 {
36457 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36458 if (SWIG_arg_fail(3)) SWIG_fail;
36459 if (arg3 == NULL) {
36460 SWIG_null_ref("wxBitmap");
36461 }
36462 if (SWIG_arg_fail(3)) SWIG_fail;
36463 }
36464 }
36465 {
36466 PyThreadState* __tstate = wxPyBeginAllowThreads();
36467 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36468
36469 wxPyEndAllowThreads(__tstate);
36470 if (PyErr_Occurred()) SWIG_fail;
36471 }
36472 Py_INCREF(Py_None); resultobj = Py_None;
36473 return resultobj;
36474 fail:
36475 return NULL;
36476 }
36477
36478
36479 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36480 PyObject *resultobj;
36481 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36482 wxBitmap *arg2 = 0 ;
36483 PyObject * obj0 = 0 ;
36484 PyObject * obj1 = 0 ;
36485 char *kwnames[] = {
36486 (char *) "self",(char *) "bmpDisabled", NULL
36487 };
36488
36489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36491 if (SWIG_arg_fail(1)) SWIG_fail;
36492 {
36493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36494 if (SWIG_arg_fail(2)) SWIG_fail;
36495 if (arg2 == NULL) {
36496 SWIG_null_ref("wxBitmap");
36497 }
36498 if (SWIG_arg_fail(2)) SWIG_fail;
36499 }
36500 {
36501 PyThreadState* __tstate = wxPyBeginAllowThreads();
36502 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
36503
36504 wxPyEndAllowThreads(__tstate);
36505 if (PyErr_Occurred()) SWIG_fail;
36506 }
36507 Py_INCREF(Py_None); resultobj = Py_None;
36508 return resultobj;
36509 fail:
36510 return NULL;
36511 }
36512
36513
36514 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36515 PyObject *resultobj;
36516 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36517 wxBitmap *result;
36518 PyObject * obj0 = 0 ;
36519 char *kwnames[] = {
36520 (char *) "self", NULL
36521 };
36522
36523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
36524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36525 if (SWIG_arg_fail(1)) SWIG_fail;
36526 {
36527 PyThreadState* __tstate = wxPyBeginAllowThreads();
36528 {
36529 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
36530 result = (wxBitmap *) &_result_ref;
36531 }
36532
36533 wxPyEndAllowThreads(__tstate);
36534 if (PyErr_Occurred()) SWIG_fail;
36535 }
36536 {
36537 wxBitmap* resultptr = new wxBitmap(*result);
36538 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36539 }
36540 return resultobj;
36541 fail:
36542 return NULL;
36543 }
36544
36545
36546 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36547 PyObject *resultobj;
36548 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36549 int arg2 ;
36550 PyObject * obj0 = 0 ;
36551 PyObject * obj1 = 0 ;
36552 char *kwnames[] = {
36553 (char *) "self",(char *) "nWidth", NULL
36554 };
36555
36556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
36557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36558 if (SWIG_arg_fail(1)) SWIG_fail;
36559 {
36560 arg2 = (int)(SWIG_As_int(obj1));
36561 if (SWIG_arg_fail(2)) SWIG_fail;
36562 }
36563 {
36564 PyThreadState* __tstate = wxPyBeginAllowThreads();
36565 wxMenuItem_SetMarginWidth(arg1,arg2);
36566
36567 wxPyEndAllowThreads(__tstate);
36568 if (PyErr_Occurred()) SWIG_fail;
36569 }
36570 Py_INCREF(Py_None); resultobj = Py_None;
36571 return resultobj;
36572 fail:
36573 return NULL;
36574 }
36575
36576
36577 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36578 PyObject *resultobj;
36579 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36580 int result;
36581 PyObject * obj0 = 0 ;
36582 char *kwnames[] = {
36583 (char *) "self", NULL
36584 };
36585
36586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
36587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36588 if (SWIG_arg_fail(1)) SWIG_fail;
36589 {
36590 PyThreadState* __tstate = wxPyBeginAllowThreads();
36591 result = (int)wxMenuItem_GetMarginWidth(arg1);
36592
36593 wxPyEndAllowThreads(__tstate);
36594 if (PyErr_Occurred()) SWIG_fail;
36595 }
36596 {
36597 resultobj = SWIG_From_int((int)(result));
36598 }
36599 return resultobj;
36600 fail:
36601 return NULL;
36602 }
36603
36604
36605 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36606 PyObject *resultobj;
36607 int result;
36608 char *kwnames[] = {
36609 NULL
36610 };
36611
36612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36613 {
36614 PyThreadState* __tstate = wxPyBeginAllowThreads();
36615 result = (int)MenuItem_GetDefaultMarginWidth();
36616
36617 wxPyEndAllowThreads(__tstate);
36618 if (PyErr_Occurred()) SWIG_fail;
36619 }
36620 {
36621 resultobj = SWIG_From_int((int)(result));
36622 }
36623 return resultobj;
36624 fail:
36625 return NULL;
36626 }
36627
36628
36629 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36630 PyObject *resultobj;
36631 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36632 bool result;
36633 PyObject * obj0 = 0 ;
36634 char *kwnames[] = {
36635 (char *) "self", NULL
36636 };
36637
36638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
36639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36640 if (SWIG_arg_fail(1)) SWIG_fail;
36641 {
36642 PyThreadState* __tstate = wxPyBeginAllowThreads();
36643 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
36644
36645 wxPyEndAllowThreads(__tstate);
36646 if (PyErr_Occurred()) SWIG_fail;
36647 }
36648 {
36649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36650 }
36651 return resultobj;
36652 fail:
36653 return NULL;
36654 }
36655
36656
36657 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36658 PyObject *resultobj;
36659 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36660 bool arg2 = (bool) true ;
36661 PyObject * obj0 = 0 ;
36662 PyObject * obj1 = 0 ;
36663 char *kwnames[] = {
36664 (char *) "self",(char *) "ownerDrawn", NULL
36665 };
36666
36667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
36668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36669 if (SWIG_arg_fail(1)) SWIG_fail;
36670 if (obj1) {
36671 {
36672 arg2 = (bool)(SWIG_As_bool(obj1));
36673 if (SWIG_arg_fail(2)) SWIG_fail;
36674 }
36675 }
36676 {
36677 PyThreadState* __tstate = wxPyBeginAllowThreads();
36678 wxMenuItem_SetOwnerDrawn(arg1,arg2);
36679
36680 wxPyEndAllowThreads(__tstate);
36681 if (PyErr_Occurred()) SWIG_fail;
36682 }
36683 Py_INCREF(Py_None); resultobj = Py_None;
36684 return resultobj;
36685 fail:
36686 return NULL;
36687 }
36688
36689
36690 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
36691 PyObject *resultobj;
36692 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36693 PyObject * obj0 = 0 ;
36694 char *kwnames[] = {
36695 (char *) "self", NULL
36696 };
36697
36698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
36699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36700 if (SWIG_arg_fail(1)) SWIG_fail;
36701 {
36702 PyThreadState* __tstate = wxPyBeginAllowThreads();
36703 wxMenuItem_ResetOwnerDrawn(arg1);
36704
36705 wxPyEndAllowThreads(__tstate);
36706 if (PyErr_Occurred()) SWIG_fail;
36707 }
36708 Py_INCREF(Py_None); resultobj = Py_None;
36709 return resultobj;
36710 fail:
36711 return NULL;
36712 }
36713
36714
36715 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36716 PyObject *resultobj;
36717 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36718 wxBitmap *arg2 = 0 ;
36719 PyObject * obj0 = 0 ;
36720 PyObject * obj1 = 0 ;
36721 char *kwnames[] = {
36722 (char *) "self",(char *) "bitmap", NULL
36723 };
36724
36725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36727 if (SWIG_arg_fail(1)) SWIG_fail;
36728 {
36729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36730 if (SWIG_arg_fail(2)) SWIG_fail;
36731 if (arg2 == NULL) {
36732 SWIG_null_ref("wxBitmap");
36733 }
36734 if (SWIG_arg_fail(2)) SWIG_fail;
36735 }
36736 {
36737 PyThreadState* __tstate = wxPyBeginAllowThreads();
36738 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36739
36740 wxPyEndAllowThreads(__tstate);
36741 if (PyErr_Occurred()) SWIG_fail;
36742 }
36743 Py_INCREF(Py_None); resultobj = Py_None;
36744 return resultobj;
36745 fail:
36746 return NULL;
36747 }
36748
36749
36750 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36751 PyObject *resultobj;
36752 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36753 wxBitmap *result;
36754 PyObject * obj0 = 0 ;
36755 char *kwnames[] = {
36756 (char *) "self", NULL
36757 };
36758
36759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36761 if (SWIG_arg_fail(1)) SWIG_fail;
36762 {
36763 PyThreadState* __tstate = wxPyBeginAllowThreads();
36764 {
36765 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36766 result = (wxBitmap *) &_result_ref;
36767 }
36768
36769 wxPyEndAllowThreads(__tstate);
36770 if (PyErr_Occurred()) SWIG_fail;
36771 }
36772 {
36773 wxBitmap* resultptr = new wxBitmap(*result);
36774 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36775 }
36776 return resultobj;
36777 fail:
36778 return NULL;
36779 }
36780
36781
36782 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36783 PyObject *obj;
36784 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36785 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36786 Py_INCREF(obj);
36787 return Py_BuildValue((char *)"");
36788 }
36789 static int _wrap_ControlNameStr_set(PyObject *) {
36790 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36791 return 1;
36792 }
36793
36794
36795 static PyObject *_wrap_ControlNameStr_get(void) {
36796 PyObject *pyobj;
36797
36798 {
36799 #if wxUSE_UNICODE
36800 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36801 #else
36802 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36803 #endif
36804 }
36805 return pyobj;
36806 }
36807
36808
36809 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36810 PyObject *resultobj;
36811 wxWindow *arg1 = (wxWindow *) 0 ;
36812 int arg2 = (int) -1 ;
36813 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36814 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36815 wxSize const &arg4_defvalue = wxDefaultSize ;
36816 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36817 long arg5 = (long) 0 ;
36818 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36819 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36820 wxString const &arg7_defvalue = wxPyControlNameStr ;
36821 wxString *arg7 = (wxString *) &arg7_defvalue ;
36822 wxControl *result;
36823 wxPoint temp3 ;
36824 wxSize temp4 ;
36825 bool temp7 = false ;
36826 PyObject * obj0 = 0 ;
36827 PyObject * obj1 = 0 ;
36828 PyObject * obj2 = 0 ;
36829 PyObject * obj3 = 0 ;
36830 PyObject * obj4 = 0 ;
36831 PyObject * obj5 = 0 ;
36832 PyObject * obj6 = 0 ;
36833 char *kwnames[] = {
36834 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36835 };
36836
36837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36839 if (SWIG_arg_fail(1)) SWIG_fail;
36840 if (obj1) {
36841 {
36842 arg2 = (int)(SWIG_As_int(obj1));
36843 if (SWIG_arg_fail(2)) SWIG_fail;
36844 }
36845 }
36846 if (obj2) {
36847 {
36848 arg3 = &temp3;
36849 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36850 }
36851 }
36852 if (obj3) {
36853 {
36854 arg4 = &temp4;
36855 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36856 }
36857 }
36858 if (obj4) {
36859 {
36860 arg5 = (long)(SWIG_As_long(obj4));
36861 if (SWIG_arg_fail(5)) SWIG_fail;
36862 }
36863 }
36864 if (obj5) {
36865 {
36866 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36867 if (SWIG_arg_fail(6)) SWIG_fail;
36868 if (arg6 == NULL) {
36869 SWIG_null_ref("wxValidator");
36870 }
36871 if (SWIG_arg_fail(6)) SWIG_fail;
36872 }
36873 }
36874 if (obj6) {
36875 {
36876 arg7 = wxString_in_helper(obj6);
36877 if (arg7 == NULL) SWIG_fail;
36878 temp7 = true;
36879 }
36880 }
36881 {
36882 if (!wxPyCheckForApp()) SWIG_fail;
36883 PyThreadState* __tstate = wxPyBeginAllowThreads();
36884 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36885
36886 wxPyEndAllowThreads(__tstate);
36887 if (PyErr_Occurred()) SWIG_fail;
36888 }
36889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36890 {
36891 if (temp7)
36892 delete arg7;
36893 }
36894 return resultobj;
36895 fail:
36896 {
36897 if (temp7)
36898 delete arg7;
36899 }
36900 return NULL;
36901 }
36902
36903
36904 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36905 PyObject *resultobj;
36906 wxControl *result;
36907 char *kwnames[] = {
36908 NULL
36909 };
36910
36911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36912 {
36913 if (!wxPyCheckForApp()) SWIG_fail;
36914 PyThreadState* __tstate = wxPyBeginAllowThreads();
36915 result = (wxControl *)new wxControl();
36916
36917 wxPyEndAllowThreads(__tstate);
36918 if (PyErr_Occurred()) SWIG_fail;
36919 }
36920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36921 return resultobj;
36922 fail:
36923 return NULL;
36924 }
36925
36926
36927 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36928 PyObject *resultobj;
36929 wxControl *arg1 = (wxControl *) 0 ;
36930 wxWindow *arg2 = (wxWindow *) 0 ;
36931 int arg3 = (int) -1 ;
36932 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36933 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36934 wxSize const &arg5_defvalue = wxDefaultSize ;
36935 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36936 long arg6 = (long) 0 ;
36937 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36938 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36939 wxString const &arg8_defvalue = wxPyControlNameStr ;
36940 wxString *arg8 = (wxString *) &arg8_defvalue ;
36941 bool result;
36942 wxPoint temp4 ;
36943 wxSize temp5 ;
36944 bool temp8 = false ;
36945 PyObject * obj0 = 0 ;
36946 PyObject * obj1 = 0 ;
36947 PyObject * obj2 = 0 ;
36948 PyObject * obj3 = 0 ;
36949 PyObject * obj4 = 0 ;
36950 PyObject * obj5 = 0 ;
36951 PyObject * obj6 = 0 ;
36952 PyObject * obj7 = 0 ;
36953 char *kwnames[] = {
36954 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36955 };
36956
36957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36959 if (SWIG_arg_fail(1)) SWIG_fail;
36960 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36961 if (SWIG_arg_fail(2)) SWIG_fail;
36962 if (obj2) {
36963 {
36964 arg3 = (int)(SWIG_As_int(obj2));
36965 if (SWIG_arg_fail(3)) SWIG_fail;
36966 }
36967 }
36968 if (obj3) {
36969 {
36970 arg4 = &temp4;
36971 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36972 }
36973 }
36974 if (obj4) {
36975 {
36976 arg5 = &temp5;
36977 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36978 }
36979 }
36980 if (obj5) {
36981 {
36982 arg6 = (long)(SWIG_As_long(obj5));
36983 if (SWIG_arg_fail(6)) SWIG_fail;
36984 }
36985 }
36986 if (obj6) {
36987 {
36988 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36989 if (SWIG_arg_fail(7)) SWIG_fail;
36990 if (arg7 == NULL) {
36991 SWIG_null_ref("wxValidator");
36992 }
36993 if (SWIG_arg_fail(7)) SWIG_fail;
36994 }
36995 }
36996 if (obj7) {
36997 {
36998 arg8 = wxString_in_helper(obj7);
36999 if (arg8 == NULL) SWIG_fail;
37000 temp8 = true;
37001 }
37002 }
37003 {
37004 PyThreadState* __tstate = wxPyBeginAllowThreads();
37005 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37006
37007 wxPyEndAllowThreads(__tstate);
37008 if (PyErr_Occurred()) SWIG_fail;
37009 }
37010 {
37011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37012 }
37013 {
37014 if (temp8)
37015 delete arg8;
37016 }
37017 return resultobj;
37018 fail:
37019 {
37020 if (temp8)
37021 delete arg8;
37022 }
37023 return NULL;
37024 }
37025
37026
37027 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37028 PyObject *resultobj;
37029 wxControl *arg1 = (wxControl *) 0 ;
37030 wxCommandEvent *arg2 = 0 ;
37031 PyObject * obj0 = 0 ;
37032 PyObject * obj1 = 0 ;
37033 char *kwnames[] = {
37034 (char *) "self",(char *) "event", NULL
37035 };
37036
37037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37039 if (SWIG_arg_fail(1)) SWIG_fail;
37040 {
37041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37042 if (SWIG_arg_fail(2)) SWIG_fail;
37043 if (arg2 == NULL) {
37044 SWIG_null_ref("wxCommandEvent");
37045 }
37046 if (SWIG_arg_fail(2)) SWIG_fail;
37047 }
37048 {
37049 PyThreadState* __tstate = wxPyBeginAllowThreads();
37050 (arg1)->Command(*arg2);
37051
37052 wxPyEndAllowThreads(__tstate);
37053 if (PyErr_Occurred()) SWIG_fail;
37054 }
37055 Py_INCREF(Py_None); resultobj = Py_None;
37056 return resultobj;
37057 fail:
37058 return NULL;
37059 }
37060
37061
37062 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37063 PyObject *resultobj;
37064 wxControl *arg1 = (wxControl *) 0 ;
37065 wxString result;
37066 PyObject * obj0 = 0 ;
37067 char *kwnames[] = {
37068 (char *) "self", NULL
37069 };
37070
37071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37073 if (SWIG_arg_fail(1)) SWIG_fail;
37074 {
37075 PyThreadState* __tstate = wxPyBeginAllowThreads();
37076 result = (arg1)->GetLabel();
37077
37078 wxPyEndAllowThreads(__tstate);
37079 if (PyErr_Occurred()) SWIG_fail;
37080 }
37081 {
37082 #if wxUSE_UNICODE
37083 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37084 #else
37085 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37086 #endif
37087 }
37088 return resultobj;
37089 fail:
37090 return NULL;
37091 }
37092
37093
37094 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37095 PyObject *resultobj;
37096 wxControl *arg1 = (wxControl *) 0 ;
37097 wxString *arg2 = 0 ;
37098 bool temp2 = false ;
37099 PyObject * obj0 = 0 ;
37100 PyObject * obj1 = 0 ;
37101 char *kwnames[] = {
37102 (char *) "self",(char *) "label", NULL
37103 };
37104
37105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37107 if (SWIG_arg_fail(1)) SWIG_fail;
37108 {
37109 arg2 = wxString_in_helper(obj1);
37110 if (arg2 == NULL) SWIG_fail;
37111 temp2 = true;
37112 }
37113 {
37114 PyThreadState* __tstate = wxPyBeginAllowThreads();
37115 (arg1)->SetLabel((wxString const &)*arg2);
37116
37117 wxPyEndAllowThreads(__tstate);
37118 if (PyErr_Occurred()) SWIG_fail;
37119 }
37120 Py_INCREF(Py_None); resultobj = Py_None;
37121 {
37122 if (temp2)
37123 delete arg2;
37124 }
37125 return resultobj;
37126 fail:
37127 {
37128 if (temp2)
37129 delete arg2;
37130 }
37131 return NULL;
37132 }
37133
37134
37135 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37136 PyObject *resultobj;
37137 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37138 wxVisualAttributes result;
37139 PyObject * obj0 = 0 ;
37140 char *kwnames[] = {
37141 (char *) "variant", NULL
37142 };
37143
37144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37145 if (obj0) {
37146 {
37147 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37148 if (SWIG_arg_fail(1)) SWIG_fail;
37149 }
37150 }
37151 {
37152 if (!wxPyCheckForApp()) SWIG_fail;
37153 PyThreadState* __tstate = wxPyBeginAllowThreads();
37154 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37155
37156 wxPyEndAllowThreads(__tstate);
37157 if (PyErr_Occurred()) SWIG_fail;
37158 }
37159 {
37160 wxVisualAttributes * resultptr;
37161 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37162 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37163 }
37164 return resultobj;
37165 fail:
37166 return NULL;
37167 }
37168
37169
37170 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37171 PyObject *obj;
37172 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37173 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37174 Py_INCREF(obj);
37175 return Py_BuildValue((char *)"");
37176 }
37177 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37178 PyObject *resultobj;
37179 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37180 wxString *arg2 = 0 ;
37181 PyObject *arg3 = (PyObject *) NULL ;
37182 int result;
37183 bool temp2 = false ;
37184 PyObject * obj0 = 0 ;
37185 PyObject * obj1 = 0 ;
37186 PyObject * obj2 = 0 ;
37187 char *kwnames[] = {
37188 (char *) "self",(char *) "item",(char *) "clientData", NULL
37189 };
37190
37191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37193 if (SWIG_arg_fail(1)) SWIG_fail;
37194 {
37195 arg2 = wxString_in_helper(obj1);
37196 if (arg2 == NULL) SWIG_fail;
37197 temp2 = true;
37198 }
37199 if (obj2) {
37200 arg3 = obj2;
37201 }
37202 {
37203 PyThreadState* __tstate = wxPyBeginAllowThreads();
37204 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37205
37206 wxPyEndAllowThreads(__tstate);
37207 if (PyErr_Occurred()) SWIG_fail;
37208 }
37209 {
37210 resultobj = SWIG_From_int((int)(result));
37211 }
37212 {
37213 if (temp2)
37214 delete arg2;
37215 }
37216 return resultobj;
37217 fail:
37218 {
37219 if (temp2)
37220 delete arg2;
37221 }
37222 return NULL;
37223 }
37224
37225
37226 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37227 PyObject *resultobj;
37228 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37229 wxArrayString *arg2 = 0 ;
37230 bool temp2 = false ;
37231 PyObject * obj0 = 0 ;
37232 PyObject * obj1 = 0 ;
37233 char *kwnames[] = {
37234 (char *) "self",(char *) "strings", NULL
37235 };
37236
37237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37239 if (SWIG_arg_fail(1)) SWIG_fail;
37240 {
37241 if (! PySequence_Check(obj1)) {
37242 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37243 SWIG_fail;
37244 }
37245 arg2 = new wxArrayString;
37246 temp2 = true;
37247 int i, len=PySequence_Length(obj1);
37248 for (i=0; i<len; i++) {
37249 PyObject* item = PySequence_GetItem(obj1, i);
37250 #if wxUSE_UNICODE
37251 PyObject* str = PyObject_Unicode(item);
37252 #else
37253 PyObject* str = PyObject_Str(item);
37254 #endif
37255 if (PyErr_Occurred()) SWIG_fail;
37256 arg2->Add(Py2wxString(str));
37257 Py_DECREF(item);
37258 Py_DECREF(str);
37259 }
37260 }
37261 {
37262 PyThreadState* __tstate = wxPyBeginAllowThreads();
37263 (arg1)->Append((wxArrayString const &)*arg2);
37264
37265 wxPyEndAllowThreads(__tstate);
37266 if (PyErr_Occurred()) SWIG_fail;
37267 }
37268 Py_INCREF(Py_None); resultobj = Py_None;
37269 {
37270 if (temp2) delete arg2;
37271 }
37272 return resultobj;
37273 fail:
37274 {
37275 if (temp2) delete arg2;
37276 }
37277 return NULL;
37278 }
37279
37280
37281 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37282 PyObject *resultobj;
37283 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37284 wxString *arg2 = 0 ;
37285 int arg3 ;
37286 PyObject *arg4 = (PyObject *) NULL ;
37287 int result;
37288 bool temp2 = false ;
37289 PyObject * obj0 = 0 ;
37290 PyObject * obj1 = 0 ;
37291 PyObject * obj2 = 0 ;
37292 PyObject * obj3 = 0 ;
37293 char *kwnames[] = {
37294 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37295 };
37296
37297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37299 if (SWIG_arg_fail(1)) SWIG_fail;
37300 {
37301 arg2 = wxString_in_helper(obj1);
37302 if (arg2 == NULL) SWIG_fail;
37303 temp2 = true;
37304 }
37305 {
37306 arg3 = (int)(SWIG_As_int(obj2));
37307 if (SWIG_arg_fail(3)) SWIG_fail;
37308 }
37309 if (obj3) {
37310 arg4 = obj3;
37311 }
37312 {
37313 PyThreadState* __tstate = wxPyBeginAllowThreads();
37314 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37315
37316 wxPyEndAllowThreads(__tstate);
37317 if (PyErr_Occurred()) SWIG_fail;
37318 }
37319 {
37320 resultobj = SWIG_From_int((int)(result));
37321 }
37322 {
37323 if (temp2)
37324 delete arg2;
37325 }
37326 return resultobj;
37327 fail:
37328 {
37329 if (temp2)
37330 delete arg2;
37331 }
37332 return NULL;
37333 }
37334
37335
37336 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37337 PyObject *resultobj;
37338 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37339 PyObject * obj0 = 0 ;
37340 char *kwnames[] = {
37341 (char *) "self", NULL
37342 };
37343
37344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37346 if (SWIG_arg_fail(1)) SWIG_fail;
37347 {
37348 PyThreadState* __tstate = wxPyBeginAllowThreads();
37349 (arg1)->Clear();
37350
37351 wxPyEndAllowThreads(__tstate);
37352 if (PyErr_Occurred()) SWIG_fail;
37353 }
37354 Py_INCREF(Py_None); resultobj = Py_None;
37355 return resultobj;
37356 fail:
37357 return NULL;
37358 }
37359
37360
37361 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37362 PyObject *resultobj;
37363 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37364 int arg2 ;
37365 PyObject * obj0 = 0 ;
37366 PyObject * obj1 = 0 ;
37367 char *kwnames[] = {
37368 (char *) "self",(char *) "n", NULL
37369 };
37370
37371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37373 if (SWIG_arg_fail(1)) SWIG_fail;
37374 {
37375 arg2 = (int)(SWIG_As_int(obj1));
37376 if (SWIG_arg_fail(2)) SWIG_fail;
37377 }
37378 {
37379 PyThreadState* __tstate = wxPyBeginAllowThreads();
37380 (arg1)->Delete(arg2);
37381
37382 wxPyEndAllowThreads(__tstate);
37383 if (PyErr_Occurred()) SWIG_fail;
37384 }
37385 Py_INCREF(Py_None); resultobj = Py_None;
37386 return resultobj;
37387 fail:
37388 return NULL;
37389 }
37390
37391
37392 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37393 PyObject *resultobj;
37394 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37395 int arg2 ;
37396 PyObject *result;
37397 PyObject * obj0 = 0 ;
37398 PyObject * obj1 = 0 ;
37399 char *kwnames[] = {
37400 (char *) "self",(char *) "n", NULL
37401 };
37402
37403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37405 if (SWIG_arg_fail(1)) SWIG_fail;
37406 {
37407 arg2 = (int)(SWIG_As_int(obj1));
37408 if (SWIG_arg_fail(2)) SWIG_fail;
37409 }
37410 {
37411 PyThreadState* __tstate = wxPyBeginAllowThreads();
37412 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37413
37414 wxPyEndAllowThreads(__tstate);
37415 if (PyErr_Occurred()) SWIG_fail;
37416 }
37417 resultobj = result;
37418 return resultobj;
37419 fail:
37420 return NULL;
37421 }
37422
37423
37424 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37425 PyObject *resultobj;
37426 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37427 int arg2 ;
37428 PyObject *arg3 = (PyObject *) 0 ;
37429 PyObject * obj0 = 0 ;
37430 PyObject * obj1 = 0 ;
37431 PyObject * obj2 = 0 ;
37432 char *kwnames[] = {
37433 (char *) "self",(char *) "n",(char *) "clientData", NULL
37434 };
37435
37436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37438 if (SWIG_arg_fail(1)) SWIG_fail;
37439 {
37440 arg2 = (int)(SWIG_As_int(obj1));
37441 if (SWIG_arg_fail(2)) SWIG_fail;
37442 }
37443 arg3 = obj2;
37444 {
37445 PyThreadState* __tstate = wxPyBeginAllowThreads();
37446 wxItemContainer_SetClientData(arg1,arg2,arg3);
37447
37448 wxPyEndAllowThreads(__tstate);
37449 if (PyErr_Occurred()) SWIG_fail;
37450 }
37451 Py_INCREF(Py_None); resultobj = Py_None;
37452 return resultobj;
37453 fail:
37454 return NULL;
37455 }
37456
37457
37458 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37459 PyObject *resultobj;
37460 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37461 int result;
37462 PyObject * obj0 = 0 ;
37463 char *kwnames[] = {
37464 (char *) "self", NULL
37465 };
37466
37467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37469 if (SWIG_arg_fail(1)) SWIG_fail;
37470 {
37471 PyThreadState* __tstate = wxPyBeginAllowThreads();
37472 result = (int)((wxItemContainer const *)arg1)->GetCount();
37473
37474 wxPyEndAllowThreads(__tstate);
37475 if (PyErr_Occurred()) SWIG_fail;
37476 }
37477 {
37478 resultobj = SWIG_From_int((int)(result));
37479 }
37480 return resultobj;
37481 fail:
37482 return NULL;
37483 }
37484
37485
37486 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37487 PyObject *resultobj;
37488 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37489 bool result;
37490 PyObject * obj0 = 0 ;
37491 char *kwnames[] = {
37492 (char *) "self", NULL
37493 };
37494
37495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37497 if (SWIG_arg_fail(1)) SWIG_fail;
37498 {
37499 PyThreadState* __tstate = wxPyBeginAllowThreads();
37500 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37501
37502 wxPyEndAllowThreads(__tstate);
37503 if (PyErr_Occurred()) SWIG_fail;
37504 }
37505 {
37506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37507 }
37508 return resultobj;
37509 fail:
37510 return NULL;
37511 }
37512
37513
37514 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
37515 PyObject *resultobj;
37516 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37517 int arg2 ;
37518 wxString result;
37519 PyObject * obj0 = 0 ;
37520 PyObject * obj1 = 0 ;
37521 char *kwnames[] = {
37522 (char *) "self",(char *) "n", NULL
37523 };
37524
37525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
37526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37527 if (SWIG_arg_fail(1)) SWIG_fail;
37528 {
37529 arg2 = (int)(SWIG_As_int(obj1));
37530 if (SWIG_arg_fail(2)) SWIG_fail;
37531 }
37532 {
37533 PyThreadState* __tstate = wxPyBeginAllowThreads();
37534 result = ((wxItemContainer const *)arg1)->GetString(arg2);
37535
37536 wxPyEndAllowThreads(__tstate);
37537 if (PyErr_Occurred()) SWIG_fail;
37538 }
37539 {
37540 #if wxUSE_UNICODE
37541 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37542 #else
37543 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37544 #endif
37545 }
37546 return resultobj;
37547 fail:
37548 return NULL;
37549 }
37550
37551
37552 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
37553 PyObject *resultobj;
37554 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37555 wxArrayString result;
37556 PyObject * obj0 = 0 ;
37557 char *kwnames[] = {
37558 (char *) "self", NULL
37559 };
37560
37561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
37562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37563 if (SWIG_arg_fail(1)) SWIG_fail;
37564 {
37565 PyThreadState* __tstate = wxPyBeginAllowThreads();
37566 result = ((wxItemContainer const *)arg1)->GetStrings();
37567
37568 wxPyEndAllowThreads(__tstate);
37569 if (PyErr_Occurred()) SWIG_fail;
37570 }
37571 {
37572 resultobj = wxArrayString2PyList_helper(result);
37573 }
37574 return resultobj;
37575 fail:
37576 return NULL;
37577 }
37578
37579
37580 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
37581 PyObject *resultobj;
37582 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37583 int arg2 ;
37584 wxString *arg3 = 0 ;
37585 bool temp3 = false ;
37586 PyObject * obj0 = 0 ;
37587 PyObject * obj1 = 0 ;
37588 PyObject * obj2 = 0 ;
37589 char *kwnames[] = {
37590 (char *) "self",(char *) "n",(char *) "s", NULL
37591 };
37592
37593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
37594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37595 if (SWIG_arg_fail(1)) SWIG_fail;
37596 {
37597 arg2 = (int)(SWIG_As_int(obj1));
37598 if (SWIG_arg_fail(2)) SWIG_fail;
37599 }
37600 {
37601 arg3 = wxString_in_helper(obj2);
37602 if (arg3 == NULL) SWIG_fail;
37603 temp3 = true;
37604 }
37605 {
37606 PyThreadState* __tstate = wxPyBeginAllowThreads();
37607 (arg1)->SetString(arg2,(wxString const &)*arg3);
37608
37609 wxPyEndAllowThreads(__tstate);
37610 if (PyErr_Occurred()) SWIG_fail;
37611 }
37612 Py_INCREF(Py_None); resultobj = Py_None;
37613 {
37614 if (temp3)
37615 delete arg3;
37616 }
37617 return resultobj;
37618 fail:
37619 {
37620 if (temp3)
37621 delete arg3;
37622 }
37623 return NULL;
37624 }
37625
37626
37627 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37628 PyObject *resultobj;
37629 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37630 wxString *arg2 = 0 ;
37631 int result;
37632 bool temp2 = false ;
37633 PyObject * obj0 = 0 ;
37634 PyObject * obj1 = 0 ;
37635 char *kwnames[] = {
37636 (char *) "self",(char *) "s", NULL
37637 };
37638
37639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37641 if (SWIG_arg_fail(1)) SWIG_fail;
37642 {
37643 arg2 = wxString_in_helper(obj1);
37644 if (arg2 == NULL) SWIG_fail;
37645 temp2 = true;
37646 }
37647 {
37648 PyThreadState* __tstate = wxPyBeginAllowThreads();
37649 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37650
37651 wxPyEndAllowThreads(__tstate);
37652 if (PyErr_Occurred()) SWIG_fail;
37653 }
37654 {
37655 resultobj = SWIG_From_int((int)(result));
37656 }
37657 {
37658 if (temp2)
37659 delete arg2;
37660 }
37661 return resultobj;
37662 fail:
37663 {
37664 if (temp2)
37665 delete arg2;
37666 }
37667 return NULL;
37668 }
37669
37670
37671 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37672 PyObject *resultobj;
37673 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37674 int arg2 ;
37675 PyObject * obj0 = 0 ;
37676 PyObject * obj1 = 0 ;
37677 char *kwnames[] = {
37678 (char *) "self",(char *) "n", NULL
37679 };
37680
37681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
37682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37683 if (SWIG_arg_fail(1)) SWIG_fail;
37684 {
37685 arg2 = (int)(SWIG_As_int(obj1));
37686 if (SWIG_arg_fail(2)) SWIG_fail;
37687 }
37688 {
37689 PyThreadState* __tstate = wxPyBeginAllowThreads();
37690 (arg1)->SetSelection(arg2);
37691
37692 wxPyEndAllowThreads(__tstate);
37693 if (PyErr_Occurred()) SWIG_fail;
37694 }
37695 Py_INCREF(Py_None); resultobj = Py_None;
37696 return resultobj;
37697 fail:
37698 return NULL;
37699 }
37700
37701
37702 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37703 PyObject *resultobj;
37704 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37705 int result;
37706 PyObject * obj0 = 0 ;
37707 char *kwnames[] = {
37708 (char *) "self", NULL
37709 };
37710
37711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37713 if (SWIG_arg_fail(1)) SWIG_fail;
37714 {
37715 PyThreadState* __tstate = wxPyBeginAllowThreads();
37716 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37717
37718 wxPyEndAllowThreads(__tstate);
37719 if (PyErr_Occurred()) SWIG_fail;
37720 }
37721 {
37722 resultobj = SWIG_From_int((int)(result));
37723 }
37724 return resultobj;
37725 fail:
37726 return NULL;
37727 }
37728
37729
37730 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37731 PyObject *resultobj;
37732 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37733 wxString *arg2 = 0 ;
37734 bool result;
37735 bool temp2 = false ;
37736 PyObject * obj0 = 0 ;
37737 PyObject * obj1 = 0 ;
37738 char *kwnames[] = {
37739 (char *) "self",(char *) "s", NULL
37740 };
37741
37742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
37743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37744 if (SWIG_arg_fail(1)) SWIG_fail;
37745 {
37746 arg2 = wxString_in_helper(obj1);
37747 if (arg2 == NULL) SWIG_fail;
37748 temp2 = true;
37749 }
37750 {
37751 PyThreadState* __tstate = wxPyBeginAllowThreads();
37752 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
37753
37754 wxPyEndAllowThreads(__tstate);
37755 if (PyErr_Occurred()) SWIG_fail;
37756 }
37757 {
37758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37759 }
37760 {
37761 if (temp2)
37762 delete arg2;
37763 }
37764 return resultobj;
37765 fail:
37766 {
37767 if (temp2)
37768 delete arg2;
37769 }
37770 return NULL;
37771 }
37772
37773
37774 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37775 PyObject *resultobj;
37776 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37777 wxString result;
37778 PyObject * obj0 = 0 ;
37779 char *kwnames[] = {
37780 (char *) "self", NULL
37781 };
37782
37783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37785 if (SWIG_arg_fail(1)) SWIG_fail;
37786 {
37787 PyThreadState* __tstate = wxPyBeginAllowThreads();
37788 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37789
37790 wxPyEndAllowThreads(__tstate);
37791 if (PyErr_Occurred()) SWIG_fail;
37792 }
37793 {
37794 #if wxUSE_UNICODE
37795 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37796 #else
37797 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37798 #endif
37799 }
37800 return resultobj;
37801 fail:
37802 return NULL;
37803 }
37804
37805
37806 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37807 PyObject *resultobj;
37808 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37809 int arg2 ;
37810 PyObject * obj0 = 0 ;
37811 PyObject * obj1 = 0 ;
37812 char *kwnames[] = {
37813 (char *) "self",(char *) "n", NULL
37814 };
37815
37816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37818 if (SWIG_arg_fail(1)) SWIG_fail;
37819 {
37820 arg2 = (int)(SWIG_As_int(obj1));
37821 if (SWIG_arg_fail(2)) SWIG_fail;
37822 }
37823 {
37824 PyThreadState* __tstate = wxPyBeginAllowThreads();
37825 (arg1)->Select(arg2);
37826
37827 wxPyEndAllowThreads(__tstate);
37828 if (PyErr_Occurred()) SWIG_fail;
37829 }
37830 Py_INCREF(Py_None); resultobj = Py_None;
37831 return resultobj;
37832 fail:
37833 return NULL;
37834 }
37835
37836
37837 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37838 PyObject *obj;
37839 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37840 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37841 Py_INCREF(obj);
37842 return Py_BuildValue((char *)"");
37843 }
37844 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37845 PyObject *obj;
37846 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37847 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37848 Py_INCREF(obj);
37849 return Py_BuildValue((char *)"");
37850 }
37851 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37852 PyObject *resultobj;
37853 wxSizerItem *result;
37854 char *kwnames[] = {
37855 NULL
37856 };
37857
37858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37859 {
37860 PyThreadState* __tstate = wxPyBeginAllowThreads();
37861 result = (wxSizerItem *)new wxSizerItem();
37862
37863 wxPyEndAllowThreads(__tstate);
37864 if (PyErr_Occurred()) SWIG_fail;
37865 }
37866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37867 return resultobj;
37868 fail:
37869 return NULL;
37870 }
37871
37872
37873 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37874 PyObject *resultobj;
37875 wxWindow *arg1 = (wxWindow *) 0 ;
37876 int arg2 ;
37877 int arg3 ;
37878 int arg4 ;
37879 PyObject *arg5 = (PyObject *) NULL ;
37880 wxSizerItem *result;
37881 PyObject * obj0 = 0 ;
37882 PyObject * obj1 = 0 ;
37883 PyObject * obj2 = 0 ;
37884 PyObject * obj3 = 0 ;
37885 PyObject * obj4 = 0 ;
37886 char *kwnames[] = {
37887 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37888 };
37889
37890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37892 if (SWIG_arg_fail(1)) SWIG_fail;
37893 {
37894 arg2 = (int)(SWIG_As_int(obj1));
37895 if (SWIG_arg_fail(2)) SWIG_fail;
37896 }
37897 {
37898 arg3 = (int)(SWIG_As_int(obj2));
37899 if (SWIG_arg_fail(3)) SWIG_fail;
37900 }
37901 {
37902 arg4 = (int)(SWIG_As_int(obj3));
37903 if (SWIG_arg_fail(4)) SWIG_fail;
37904 }
37905 if (obj4) {
37906 arg5 = obj4;
37907 }
37908 {
37909 PyThreadState* __tstate = wxPyBeginAllowThreads();
37910 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37911
37912 wxPyEndAllowThreads(__tstate);
37913 if (PyErr_Occurred()) SWIG_fail;
37914 }
37915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37916 return resultobj;
37917 fail:
37918 return NULL;
37919 }
37920
37921
37922 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37923 PyObject *resultobj;
37924 int arg1 ;
37925 int arg2 ;
37926 int arg3 ;
37927 int arg4 ;
37928 int arg5 ;
37929 PyObject *arg6 = (PyObject *) NULL ;
37930 wxSizerItem *result;
37931 PyObject * obj0 = 0 ;
37932 PyObject * obj1 = 0 ;
37933 PyObject * obj2 = 0 ;
37934 PyObject * obj3 = 0 ;
37935 PyObject * obj4 = 0 ;
37936 PyObject * obj5 = 0 ;
37937 char *kwnames[] = {
37938 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37939 };
37940
37941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37942 {
37943 arg1 = (int)(SWIG_As_int(obj0));
37944 if (SWIG_arg_fail(1)) SWIG_fail;
37945 }
37946 {
37947 arg2 = (int)(SWIG_As_int(obj1));
37948 if (SWIG_arg_fail(2)) SWIG_fail;
37949 }
37950 {
37951 arg3 = (int)(SWIG_As_int(obj2));
37952 if (SWIG_arg_fail(3)) SWIG_fail;
37953 }
37954 {
37955 arg4 = (int)(SWIG_As_int(obj3));
37956 if (SWIG_arg_fail(4)) SWIG_fail;
37957 }
37958 {
37959 arg5 = (int)(SWIG_As_int(obj4));
37960 if (SWIG_arg_fail(5)) SWIG_fail;
37961 }
37962 if (obj5) {
37963 arg6 = obj5;
37964 }
37965 {
37966 PyThreadState* __tstate = wxPyBeginAllowThreads();
37967 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37968
37969 wxPyEndAllowThreads(__tstate);
37970 if (PyErr_Occurred()) SWIG_fail;
37971 }
37972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37973 return resultobj;
37974 fail:
37975 return NULL;
37976 }
37977
37978
37979 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37980 PyObject *resultobj;
37981 wxSizer *arg1 = (wxSizer *) 0 ;
37982 int arg2 ;
37983 int arg3 ;
37984 int arg4 ;
37985 PyObject *arg5 = (PyObject *) NULL ;
37986 wxSizerItem *result;
37987 PyObject * obj0 = 0 ;
37988 PyObject * obj1 = 0 ;
37989 PyObject * obj2 = 0 ;
37990 PyObject * obj3 = 0 ;
37991 PyObject * obj4 = 0 ;
37992 char *kwnames[] = {
37993 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37994 };
37995
37996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37998 if (SWIG_arg_fail(1)) SWIG_fail;
37999 {
38000 arg2 = (int)(SWIG_As_int(obj1));
38001 if (SWIG_arg_fail(2)) SWIG_fail;
38002 }
38003 {
38004 arg3 = (int)(SWIG_As_int(obj2));
38005 if (SWIG_arg_fail(3)) SWIG_fail;
38006 }
38007 {
38008 arg4 = (int)(SWIG_As_int(obj3));
38009 if (SWIG_arg_fail(4)) SWIG_fail;
38010 }
38011 if (obj4) {
38012 arg5 = obj4;
38013 }
38014 {
38015 PyThreadState* __tstate = wxPyBeginAllowThreads();
38016 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38017
38018 wxPyEndAllowThreads(__tstate);
38019 if (PyErr_Occurred()) SWIG_fail;
38020 }
38021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38022 return resultobj;
38023 fail:
38024 return NULL;
38025 }
38026
38027
38028 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38029 PyObject *resultobj;
38030 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38031 PyObject * obj0 = 0 ;
38032 char *kwnames[] = {
38033 (char *) "self", NULL
38034 };
38035
38036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38038 if (SWIG_arg_fail(1)) SWIG_fail;
38039 {
38040 PyThreadState* __tstate = wxPyBeginAllowThreads();
38041 (arg1)->DeleteWindows();
38042
38043 wxPyEndAllowThreads(__tstate);
38044 if (PyErr_Occurred()) SWIG_fail;
38045 }
38046 Py_INCREF(Py_None); resultobj = Py_None;
38047 return resultobj;
38048 fail:
38049 return NULL;
38050 }
38051
38052
38053 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38054 PyObject *resultobj;
38055 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38056 PyObject * obj0 = 0 ;
38057 char *kwnames[] = {
38058 (char *) "self", NULL
38059 };
38060
38061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38063 if (SWIG_arg_fail(1)) SWIG_fail;
38064 {
38065 PyThreadState* __tstate = wxPyBeginAllowThreads();
38066 (arg1)->DetachSizer();
38067
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 Py_INCREF(Py_None); resultobj = Py_None;
38072 return resultobj;
38073 fail:
38074 return NULL;
38075 }
38076
38077
38078 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38079 PyObject *resultobj;
38080 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38081 wxSize result;
38082 PyObject * obj0 = 0 ;
38083 char *kwnames[] = {
38084 (char *) "self", NULL
38085 };
38086
38087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38089 if (SWIG_arg_fail(1)) SWIG_fail;
38090 {
38091 PyThreadState* __tstate = wxPyBeginAllowThreads();
38092 result = (arg1)->GetSize();
38093
38094 wxPyEndAllowThreads(__tstate);
38095 if (PyErr_Occurred()) SWIG_fail;
38096 }
38097 {
38098 wxSize * resultptr;
38099 resultptr = new wxSize((wxSize &)(result));
38100 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38101 }
38102 return resultobj;
38103 fail:
38104 return NULL;
38105 }
38106
38107
38108 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38109 PyObject *resultobj;
38110 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38111 wxSize result;
38112 PyObject * obj0 = 0 ;
38113 char *kwnames[] = {
38114 (char *) "self", NULL
38115 };
38116
38117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38119 if (SWIG_arg_fail(1)) SWIG_fail;
38120 {
38121 PyThreadState* __tstate = wxPyBeginAllowThreads();
38122 result = (arg1)->CalcMin();
38123
38124 wxPyEndAllowThreads(__tstate);
38125 if (PyErr_Occurred()) SWIG_fail;
38126 }
38127 {
38128 wxSize * resultptr;
38129 resultptr = new wxSize((wxSize &)(result));
38130 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38131 }
38132 return resultobj;
38133 fail:
38134 return NULL;
38135 }
38136
38137
38138 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38139 PyObject *resultobj;
38140 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38141 wxPoint arg2 ;
38142 wxSize arg3 ;
38143 PyObject * obj0 = 0 ;
38144 PyObject * obj1 = 0 ;
38145 PyObject * obj2 = 0 ;
38146 char *kwnames[] = {
38147 (char *) "self",(char *) "pos",(char *) "size", NULL
38148 };
38149
38150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38152 if (SWIG_arg_fail(1)) SWIG_fail;
38153 {
38154 wxPoint * argp;
38155 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38156 if (SWIG_arg_fail(2)) SWIG_fail;
38157 if (argp == NULL) {
38158 SWIG_null_ref("wxPoint");
38159 }
38160 if (SWIG_arg_fail(2)) SWIG_fail;
38161 arg2 = *argp;
38162 }
38163 {
38164 wxSize * argp;
38165 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38166 if (SWIG_arg_fail(3)) SWIG_fail;
38167 if (argp == NULL) {
38168 SWIG_null_ref("wxSize");
38169 }
38170 if (SWIG_arg_fail(3)) SWIG_fail;
38171 arg3 = *argp;
38172 }
38173 {
38174 PyThreadState* __tstate = wxPyBeginAllowThreads();
38175 (arg1)->SetDimension(arg2,arg3);
38176
38177 wxPyEndAllowThreads(__tstate);
38178 if (PyErr_Occurred()) SWIG_fail;
38179 }
38180 Py_INCREF(Py_None); resultobj = Py_None;
38181 return resultobj;
38182 fail:
38183 return NULL;
38184 }
38185
38186
38187 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38188 PyObject *resultobj;
38189 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38190 wxSize result;
38191 PyObject * obj0 = 0 ;
38192 char *kwnames[] = {
38193 (char *) "self", NULL
38194 };
38195
38196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38198 if (SWIG_arg_fail(1)) SWIG_fail;
38199 {
38200 PyThreadState* __tstate = wxPyBeginAllowThreads();
38201 result = (arg1)->GetMinSize();
38202
38203 wxPyEndAllowThreads(__tstate);
38204 if (PyErr_Occurred()) SWIG_fail;
38205 }
38206 {
38207 wxSize * resultptr;
38208 resultptr = new wxSize((wxSize &)(result));
38209 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38210 }
38211 return resultobj;
38212 fail:
38213 return NULL;
38214 }
38215
38216
38217 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38218 PyObject *resultobj;
38219 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38220 wxSize result;
38221 PyObject * obj0 = 0 ;
38222 char *kwnames[] = {
38223 (char *) "self", NULL
38224 };
38225
38226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38228 if (SWIG_arg_fail(1)) SWIG_fail;
38229 {
38230 PyThreadState* __tstate = wxPyBeginAllowThreads();
38231 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38232
38233 wxPyEndAllowThreads(__tstate);
38234 if (PyErr_Occurred()) SWIG_fail;
38235 }
38236 {
38237 wxSize * resultptr;
38238 resultptr = new wxSize((wxSize &)(result));
38239 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38240 }
38241 return resultobj;
38242 fail:
38243 return NULL;
38244 }
38245
38246
38247 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38248 PyObject *resultobj;
38249 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38250 int arg2 ;
38251 int arg3 ;
38252 PyObject * obj0 = 0 ;
38253 PyObject * obj1 = 0 ;
38254 PyObject * obj2 = 0 ;
38255 char *kwnames[] = {
38256 (char *) "self",(char *) "x",(char *) "y", NULL
38257 };
38258
38259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38261 if (SWIG_arg_fail(1)) SWIG_fail;
38262 {
38263 arg2 = (int)(SWIG_As_int(obj1));
38264 if (SWIG_arg_fail(2)) SWIG_fail;
38265 }
38266 {
38267 arg3 = (int)(SWIG_As_int(obj2));
38268 if (SWIG_arg_fail(3)) SWIG_fail;
38269 }
38270 {
38271 PyThreadState* __tstate = wxPyBeginAllowThreads();
38272 (arg1)->SetInitSize(arg2,arg3);
38273
38274 wxPyEndAllowThreads(__tstate);
38275 if (PyErr_Occurred()) SWIG_fail;
38276 }
38277 Py_INCREF(Py_None); resultobj = Py_None;
38278 return resultobj;
38279 fail:
38280 return NULL;
38281 }
38282
38283
38284 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38285 PyObject *resultobj;
38286 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38287 int arg2 ;
38288 int arg3 ;
38289 PyObject * obj0 = 0 ;
38290 PyObject * obj1 = 0 ;
38291 PyObject * obj2 = 0 ;
38292 char *kwnames[] = {
38293 (char *) "self",(char *) "width",(char *) "height", NULL
38294 };
38295
38296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38298 if (SWIG_arg_fail(1)) SWIG_fail;
38299 {
38300 arg2 = (int)(SWIG_As_int(obj1));
38301 if (SWIG_arg_fail(2)) SWIG_fail;
38302 }
38303 {
38304 arg3 = (int)(SWIG_As_int(obj2));
38305 if (SWIG_arg_fail(3)) SWIG_fail;
38306 }
38307 {
38308 PyThreadState* __tstate = wxPyBeginAllowThreads();
38309 (arg1)->SetRatio(arg2,arg3);
38310
38311 wxPyEndAllowThreads(__tstate);
38312 if (PyErr_Occurred()) SWIG_fail;
38313 }
38314 Py_INCREF(Py_None); resultobj = Py_None;
38315 return resultobj;
38316 fail:
38317 return NULL;
38318 }
38319
38320
38321 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38322 PyObject *resultobj;
38323 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38324 wxSize arg2 ;
38325 PyObject * obj0 = 0 ;
38326 PyObject * obj1 = 0 ;
38327 char *kwnames[] = {
38328 (char *) "self",(char *) "size", NULL
38329 };
38330
38331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38333 if (SWIG_arg_fail(1)) SWIG_fail;
38334 {
38335 wxSize * argp;
38336 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38337 if (SWIG_arg_fail(2)) SWIG_fail;
38338 if (argp == NULL) {
38339 SWIG_null_ref("wxSize");
38340 }
38341 if (SWIG_arg_fail(2)) SWIG_fail;
38342 arg2 = *argp;
38343 }
38344 {
38345 PyThreadState* __tstate = wxPyBeginAllowThreads();
38346 (arg1)->SetRatio(arg2);
38347
38348 wxPyEndAllowThreads(__tstate);
38349 if (PyErr_Occurred()) SWIG_fail;
38350 }
38351 Py_INCREF(Py_None); resultobj = Py_None;
38352 return resultobj;
38353 fail:
38354 return NULL;
38355 }
38356
38357
38358 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38359 PyObject *resultobj;
38360 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38361 float arg2 ;
38362 PyObject * obj0 = 0 ;
38363 PyObject * obj1 = 0 ;
38364 char *kwnames[] = {
38365 (char *) "self",(char *) "ratio", NULL
38366 };
38367
38368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38370 if (SWIG_arg_fail(1)) SWIG_fail;
38371 {
38372 arg2 = (float)(SWIG_As_float(obj1));
38373 if (SWIG_arg_fail(2)) SWIG_fail;
38374 }
38375 {
38376 PyThreadState* __tstate = wxPyBeginAllowThreads();
38377 (arg1)->SetRatio(arg2);
38378
38379 wxPyEndAllowThreads(__tstate);
38380 if (PyErr_Occurred()) SWIG_fail;
38381 }
38382 Py_INCREF(Py_None); resultobj = Py_None;
38383 return resultobj;
38384 fail:
38385 return NULL;
38386 }
38387
38388
38389 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38390 PyObject *resultobj;
38391 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38392 float result;
38393 PyObject * obj0 = 0 ;
38394 char *kwnames[] = {
38395 (char *) "self", NULL
38396 };
38397
38398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38400 if (SWIG_arg_fail(1)) SWIG_fail;
38401 {
38402 PyThreadState* __tstate = wxPyBeginAllowThreads();
38403 result = (float)(arg1)->GetRatio();
38404
38405 wxPyEndAllowThreads(__tstate);
38406 if (PyErr_Occurred()) SWIG_fail;
38407 }
38408 {
38409 resultobj = SWIG_From_float((float)(result));
38410 }
38411 return resultobj;
38412 fail:
38413 return NULL;
38414 }
38415
38416
38417 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38418 PyObject *resultobj;
38419 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38420 wxRect result;
38421 PyObject * obj0 = 0 ;
38422 char *kwnames[] = {
38423 (char *) "self", NULL
38424 };
38425
38426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38428 if (SWIG_arg_fail(1)) SWIG_fail;
38429 {
38430 PyThreadState* __tstate = wxPyBeginAllowThreads();
38431 result = (arg1)->GetRect();
38432
38433 wxPyEndAllowThreads(__tstate);
38434 if (PyErr_Occurred()) SWIG_fail;
38435 }
38436 {
38437 wxRect * resultptr;
38438 resultptr = new wxRect((wxRect &)(result));
38439 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38440 }
38441 return resultobj;
38442 fail:
38443 return NULL;
38444 }
38445
38446
38447 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38448 PyObject *resultobj;
38449 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38450 bool result;
38451 PyObject * obj0 = 0 ;
38452 char *kwnames[] = {
38453 (char *) "self", NULL
38454 };
38455
38456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38458 if (SWIG_arg_fail(1)) SWIG_fail;
38459 {
38460 PyThreadState* __tstate = wxPyBeginAllowThreads();
38461 result = (bool)(arg1)->IsWindow();
38462
38463 wxPyEndAllowThreads(__tstate);
38464 if (PyErr_Occurred()) SWIG_fail;
38465 }
38466 {
38467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38468 }
38469 return resultobj;
38470 fail:
38471 return NULL;
38472 }
38473
38474
38475 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38476 PyObject *resultobj;
38477 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38478 bool result;
38479 PyObject * obj0 = 0 ;
38480 char *kwnames[] = {
38481 (char *) "self", NULL
38482 };
38483
38484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38486 if (SWIG_arg_fail(1)) SWIG_fail;
38487 {
38488 PyThreadState* __tstate = wxPyBeginAllowThreads();
38489 result = (bool)(arg1)->IsSizer();
38490
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 {
38495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38496 }
38497 return resultobj;
38498 fail:
38499 return NULL;
38500 }
38501
38502
38503 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38504 PyObject *resultobj;
38505 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38506 bool result;
38507 PyObject * obj0 = 0 ;
38508 char *kwnames[] = {
38509 (char *) "self", NULL
38510 };
38511
38512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38514 if (SWIG_arg_fail(1)) SWIG_fail;
38515 {
38516 PyThreadState* __tstate = wxPyBeginAllowThreads();
38517 result = (bool)(arg1)->IsSpacer();
38518
38519 wxPyEndAllowThreads(__tstate);
38520 if (PyErr_Occurred()) SWIG_fail;
38521 }
38522 {
38523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38524 }
38525 return resultobj;
38526 fail:
38527 return NULL;
38528 }
38529
38530
38531 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38532 PyObject *resultobj;
38533 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38534 int arg2 ;
38535 PyObject * obj0 = 0 ;
38536 PyObject * obj1 = 0 ;
38537 char *kwnames[] = {
38538 (char *) "self",(char *) "proportion", NULL
38539 };
38540
38541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
38542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38543 if (SWIG_arg_fail(1)) SWIG_fail;
38544 {
38545 arg2 = (int)(SWIG_As_int(obj1));
38546 if (SWIG_arg_fail(2)) SWIG_fail;
38547 }
38548 {
38549 PyThreadState* __tstate = wxPyBeginAllowThreads();
38550 (arg1)->SetProportion(arg2);
38551
38552 wxPyEndAllowThreads(__tstate);
38553 if (PyErr_Occurred()) SWIG_fail;
38554 }
38555 Py_INCREF(Py_None); resultobj = Py_None;
38556 return resultobj;
38557 fail:
38558 return NULL;
38559 }
38560
38561
38562 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
38563 PyObject *resultobj;
38564 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38565 int result;
38566 PyObject * obj0 = 0 ;
38567 char *kwnames[] = {
38568 (char *) "self", NULL
38569 };
38570
38571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
38572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38573 if (SWIG_arg_fail(1)) SWIG_fail;
38574 {
38575 PyThreadState* __tstate = wxPyBeginAllowThreads();
38576 result = (int)(arg1)->GetProportion();
38577
38578 wxPyEndAllowThreads(__tstate);
38579 if (PyErr_Occurred()) SWIG_fail;
38580 }
38581 {
38582 resultobj = SWIG_From_int((int)(result));
38583 }
38584 return resultobj;
38585 fail:
38586 return NULL;
38587 }
38588
38589
38590 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38591 PyObject *resultobj;
38592 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38593 int arg2 ;
38594 PyObject * obj0 = 0 ;
38595 PyObject * obj1 = 0 ;
38596 char *kwnames[] = {
38597 (char *) "self",(char *) "flag", NULL
38598 };
38599
38600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
38601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38602 if (SWIG_arg_fail(1)) SWIG_fail;
38603 {
38604 arg2 = (int)(SWIG_As_int(obj1));
38605 if (SWIG_arg_fail(2)) SWIG_fail;
38606 }
38607 {
38608 PyThreadState* __tstate = wxPyBeginAllowThreads();
38609 (arg1)->SetFlag(arg2);
38610
38611 wxPyEndAllowThreads(__tstate);
38612 if (PyErr_Occurred()) SWIG_fail;
38613 }
38614 Py_INCREF(Py_None); resultobj = Py_None;
38615 return resultobj;
38616 fail:
38617 return NULL;
38618 }
38619
38620
38621 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38622 PyObject *resultobj;
38623 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38624 int result;
38625 PyObject * obj0 = 0 ;
38626 char *kwnames[] = {
38627 (char *) "self", NULL
38628 };
38629
38630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38632 if (SWIG_arg_fail(1)) SWIG_fail;
38633 {
38634 PyThreadState* __tstate = wxPyBeginAllowThreads();
38635 result = (int)(arg1)->GetFlag();
38636
38637 wxPyEndAllowThreads(__tstate);
38638 if (PyErr_Occurred()) SWIG_fail;
38639 }
38640 {
38641 resultobj = SWIG_From_int((int)(result));
38642 }
38643 return resultobj;
38644 fail:
38645 return NULL;
38646 }
38647
38648
38649 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38650 PyObject *resultobj;
38651 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38652 int arg2 ;
38653 PyObject * obj0 = 0 ;
38654 PyObject * obj1 = 0 ;
38655 char *kwnames[] = {
38656 (char *) "self",(char *) "border", NULL
38657 };
38658
38659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38661 if (SWIG_arg_fail(1)) SWIG_fail;
38662 {
38663 arg2 = (int)(SWIG_As_int(obj1));
38664 if (SWIG_arg_fail(2)) SWIG_fail;
38665 }
38666 {
38667 PyThreadState* __tstate = wxPyBeginAllowThreads();
38668 (arg1)->SetBorder(arg2);
38669
38670 wxPyEndAllowThreads(__tstate);
38671 if (PyErr_Occurred()) SWIG_fail;
38672 }
38673 Py_INCREF(Py_None); resultobj = Py_None;
38674 return resultobj;
38675 fail:
38676 return NULL;
38677 }
38678
38679
38680 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38681 PyObject *resultobj;
38682 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38683 int result;
38684 PyObject * obj0 = 0 ;
38685 char *kwnames[] = {
38686 (char *) "self", NULL
38687 };
38688
38689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38691 if (SWIG_arg_fail(1)) SWIG_fail;
38692 {
38693 PyThreadState* __tstate = wxPyBeginAllowThreads();
38694 result = (int)(arg1)->GetBorder();
38695
38696 wxPyEndAllowThreads(__tstate);
38697 if (PyErr_Occurred()) SWIG_fail;
38698 }
38699 {
38700 resultobj = SWIG_From_int((int)(result));
38701 }
38702 return resultobj;
38703 fail:
38704 return NULL;
38705 }
38706
38707
38708 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38709 PyObject *resultobj;
38710 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38711 wxWindow *result;
38712 PyObject * obj0 = 0 ;
38713 char *kwnames[] = {
38714 (char *) "self", NULL
38715 };
38716
38717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38719 if (SWIG_arg_fail(1)) SWIG_fail;
38720 {
38721 PyThreadState* __tstate = wxPyBeginAllowThreads();
38722 result = (wxWindow *)(arg1)->GetWindow();
38723
38724 wxPyEndAllowThreads(__tstate);
38725 if (PyErr_Occurred()) SWIG_fail;
38726 }
38727 {
38728 resultobj = wxPyMake_wxObject(result, 0);
38729 }
38730 return resultobj;
38731 fail:
38732 return NULL;
38733 }
38734
38735
38736 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38737 PyObject *resultobj;
38738 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38739 wxWindow *arg2 = (wxWindow *) 0 ;
38740 PyObject * obj0 = 0 ;
38741 PyObject * obj1 = 0 ;
38742 char *kwnames[] = {
38743 (char *) "self",(char *) "window", NULL
38744 };
38745
38746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38748 if (SWIG_arg_fail(1)) SWIG_fail;
38749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38750 if (SWIG_arg_fail(2)) SWIG_fail;
38751 {
38752 PyThreadState* __tstate = wxPyBeginAllowThreads();
38753 (arg1)->SetWindow(arg2);
38754
38755 wxPyEndAllowThreads(__tstate);
38756 if (PyErr_Occurred()) SWIG_fail;
38757 }
38758 Py_INCREF(Py_None); resultobj = Py_None;
38759 return resultobj;
38760 fail:
38761 return NULL;
38762 }
38763
38764
38765 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38766 PyObject *resultobj;
38767 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38768 wxSizer *result;
38769 PyObject * obj0 = 0 ;
38770 char *kwnames[] = {
38771 (char *) "self", NULL
38772 };
38773
38774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38776 if (SWIG_arg_fail(1)) SWIG_fail;
38777 {
38778 PyThreadState* __tstate = wxPyBeginAllowThreads();
38779 result = (wxSizer *)(arg1)->GetSizer();
38780
38781 wxPyEndAllowThreads(__tstate);
38782 if (PyErr_Occurred()) SWIG_fail;
38783 }
38784 {
38785 resultobj = wxPyMake_wxSizer(result, 0);
38786 }
38787 return resultobj;
38788 fail:
38789 return NULL;
38790 }
38791
38792
38793 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38794 PyObject *resultobj;
38795 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38796 wxSizer *arg2 = (wxSizer *) 0 ;
38797 PyObject * obj0 = 0 ;
38798 PyObject * obj1 = 0 ;
38799 char *kwnames[] = {
38800 (char *) "self",(char *) "sizer", NULL
38801 };
38802
38803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38805 if (SWIG_arg_fail(1)) SWIG_fail;
38806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38807 if (SWIG_arg_fail(2)) SWIG_fail;
38808 {
38809 PyThreadState* __tstate = wxPyBeginAllowThreads();
38810 (arg1)->SetSizer(arg2);
38811
38812 wxPyEndAllowThreads(__tstate);
38813 if (PyErr_Occurred()) SWIG_fail;
38814 }
38815 Py_INCREF(Py_None); resultobj = Py_None;
38816 return resultobj;
38817 fail:
38818 return NULL;
38819 }
38820
38821
38822 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38823 PyObject *resultobj;
38824 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38825 wxSize *result;
38826 PyObject * obj0 = 0 ;
38827 char *kwnames[] = {
38828 (char *) "self", NULL
38829 };
38830
38831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38833 if (SWIG_arg_fail(1)) SWIG_fail;
38834 {
38835 PyThreadState* __tstate = wxPyBeginAllowThreads();
38836 {
38837 wxSize const &_result_ref = (arg1)->GetSpacer();
38838 result = (wxSize *) &_result_ref;
38839 }
38840
38841 wxPyEndAllowThreads(__tstate);
38842 if (PyErr_Occurred()) SWIG_fail;
38843 }
38844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38845 return resultobj;
38846 fail:
38847 return NULL;
38848 }
38849
38850
38851 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38852 PyObject *resultobj;
38853 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38854 wxSize *arg2 = 0 ;
38855 wxSize temp2 ;
38856 PyObject * obj0 = 0 ;
38857 PyObject * obj1 = 0 ;
38858 char *kwnames[] = {
38859 (char *) "self",(char *) "size", NULL
38860 };
38861
38862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38864 if (SWIG_arg_fail(1)) SWIG_fail;
38865 {
38866 arg2 = &temp2;
38867 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38868 }
38869 {
38870 PyThreadState* __tstate = wxPyBeginAllowThreads();
38871 (arg1)->SetSpacer((wxSize const &)*arg2);
38872
38873 wxPyEndAllowThreads(__tstate);
38874 if (PyErr_Occurred()) SWIG_fail;
38875 }
38876 Py_INCREF(Py_None); resultobj = Py_None;
38877 return resultobj;
38878 fail:
38879 return NULL;
38880 }
38881
38882
38883 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38884 PyObject *resultobj;
38885 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38886 bool arg2 ;
38887 PyObject * obj0 = 0 ;
38888 PyObject * obj1 = 0 ;
38889 char *kwnames[] = {
38890 (char *) "self",(char *) "show", NULL
38891 };
38892
38893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38895 if (SWIG_arg_fail(1)) SWIG_fail;
38896 {
38897 arg2 = (bool)(SWIG_As_bool(obj1));
38898 if (SWIG_arg_fail(2)) SWIG_fail;
38899 }
38900 {
38901 PyThreadState* __tstate = wxPyBeginAllowThreads();
38902 (arg1)->Show(arg2);
38903
38904 wxPyEndAllowThreads(__tstate);
38905 if (PyErr_Occurred()) SWIG_fail;
38906 }
38907 Py_INCREF(Py_None); resultobj = Py_None;
38908 return resultobj;
38909 fail:
38910 return NULL;
38911 }
38912
38913
38914 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38915 PyObject *resultobj;
38916 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38917 bool result;
38918 PyObject * obj0 = 0 ;
38919 char *kwnames[] = {
38920 (char *) "self", NULL
38921 };
38922
38923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38925 if (SWIG_arg_fail(1)) SWIG_fail;
38926 {
38927 PyThreadState* __tstate = wxPyBeginAllowThreads();
38928 result = (bool)(arg1)->IsShown();
38929
38930 wxPyEndAllowThreads(__tstate);
38931 if (PyErr_Occurred()) SWIG_fail;
38932 }
38933 {
38934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38935 }
38936 return resultobj;
38937 fail:
38938 return NULL;
38939 }
38940
38941
38942 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38943 PyObject *resultobj;
38944 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38945 wxPoint result;
38946 PyObject * obj0 = 0 ;
38947 char *kwnames[] = {
38948 (char *) "self", NULL
38949 };
38950
38951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38953 if (SWIG_arg_fail(1)) SWIG_fail;
38954 {
38955 PyThreadState* __tstate = wxPyBeginAllowThreads();
38956 result = (arg1)->GetPosition();
38957
38958 wxPyEndAllowThreads(__tstate);
38959 if (PyErr_Occurred()) SWIG_fail;
38960 }
38961 {
38962 wxPoint * resultptr;
38963 resultptr = new wxPoint((wxPoint &)(result));
38964 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38965 }
38966 return resultobj;
38967 fail:
38968 return NULL;
38969 }
38970
38971
38972 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38973 PyObject *resultobj;
38974 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38975 PyObject *result;
38976 PyObject * obj0 = 0 ;
38977 char *kwnames[] = {
38978 (char *) "self", NULL
38979 };
38980
38981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38983 if (SWIG_arg_fail(1)) SWIG_fail;
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38987
38988 wxPyEndAllowThreads(__tstate);
38989 if (PyErr_Occurred()) SWIG_fail;
38990 }
38991 resultobj = result;
38992 return resultobj;
38993 fail:
38994 return NULL;
38995 }
38996
38997
38998 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38999 PyObject *obj;
39000 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39001 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39002 Py_INCREF(obj);
39003 return Py_BuildValue((char *)"");
39004 }
39005 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39006 PyObject *resultobj;
39007 wxSizer *arg1 = (wxSizer *) 0 ;
39008 PyObject *arg2 = (PyObject *) 0 ;
39009 PyObject * obj0 = 0 ;
39010 PyObject * obj1 = 0 ;
39011 char *kwnames[] = {
39012 (char *) "self",(char *) "_self", NULL
39013 };
39014
39015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39017 if (SWIG_arg_fail(1)) SWIG_fail;
39018 arg2 = obj1;
39019 {
39020 PyThreadState* __tstate = wxPyBeginAllowThreads();
39021 wxSizer__setOORInfo(arg1,arg2);
39022
39023 wxPyEndAllowThreads(__tstate);
39024 if (PyErr_Occurred()) SWIG_fail;
39025 }
39026 Py_INCREF(Py_None); resultobj = Py_None;
39027 return resultobj;
39028 fail:
39029 return NULL;
39030 }
39031
39032
39033 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39034 PyObject *resultobj;
39035 wxSizer *arg1 = (wxSizer *) 0 ;
39036 PyObject *arg2 = (PyObject *) 0 ;
39037 int arg3 = (int) 0 ;
39038 int arg4 = (int) 0 ;
39039 int arg5 = (int) 0 ;
39040 PyObject *arg6 = (PyObject *) NULL ;
39041 wxSizerItem *result;
39042 PyObject * obj0 = 0 ;
39043 PyObject * obj1 = 0 ;
39044 PyObject * obj2 = 0 ;
39045 PyObject * obj3 = 0 ;
39046 PyObject * obj4 = 0 ;
39047 PyObject * obj5 = 0 ;
39048 char *kwnames[] = {
39049 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39050 };
39051
39052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39054 if (SWIG_arg_fail(1)) SWIG_fail;
39055 arg2 = obj1;
39056 if (obj2) {
39057 {
39058 arg3 = (int)(SWIG_As_int(obj2));
39059 if (SWIG_arg_fail(3)) SWIG_fail;
39060 }
39061 }
39062 if (obj3) {
39063 {
39064 arg4 = (int)(SWIG_As_int(obj3));
39065 if (SWIG_arg_fail(4)) SWIG_fail;
39066 }
39067 }
39068 if (obj4) {
39069 {
39070 arg5 = (int)(SWIG_As_int(obj4));
39071 if (SWIG_arg_fail(5)) SWIG_fail;
39072 }
39073 }
39074 if (obj5) {
39075 arg6 = obj5;
39076 }
39077 {
39078 PyThreadState* __tstate = wxPyBeginAllowThreads();
39079 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39080
39081 wxPyEndAllowThreads(__tstate);
39082 if (PyErr_Occurred()) SWIG_fail;
39083 }
39084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39085 return resultobj;
39086 fail:
39087 return NULL;
39088 }
39089
39090
39091 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39092 PyObject *resultobj;
39093 wxSizer *arg1 = (wxSizer *) 0 ;
39094 int arg2 ;
39095 PyObject *arg3 = (PyObject *) 0 ;
39096 int arg4 = (int) 0 ;
39097 int arg5 = (int) 0 ;
39098 int arg6 = (int) 0 ;
39099 PyObject *arg7 = (PyObject *) NULL ;
39100 wxSizerItem *result;
39101 PyObject * obj0 = 0 ;
39102 PyObject * obj1 = 0 ;
39103 PyObject * obj2 = 0 ;
39104 PyObject * obj3 = 0 ;
39105 PyObject * obj4 = 0 ;
39106 PyObject * obj5 = 0 ;
39107 PyObject * obj6 = 0 ;
39108 char *kwnames[] = {
39109 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39110 };
39111
39112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39114 if (SWIG_arg_fail(1)) SWIG_fail;
39115 {
39116 arg2 = (int)(SWIG_As_int(obj1));
39117 if (SWIG_arg_fail(2)) SWIG_fail;
39118 }
39119 arg3 = obj2;
39120 if (obj3) {
39121 {
39122 arg4 = (int)(SWIG_As_int(obj3));
39123 if (SWIG_arg_fail(4)) SWIG_fail;
39124 }
39125 }
39126 if (obj4) {
39127 {
39128 arg5 = (int)(SWIG_As_int(obj4));
39129 if (SWIG_arg_fail(5)) SWIG_fail;
39130 }
39131 }
39132 if (obj5) {
39133 {
39134 arg6 = (int)(SWIG_As_int(obj5));
39135 if (SWIG_arg_fail(6)) SWIG_fail;
39136 }
39137 }
39138 if (obj6) {
39139 arg7 = obj6;
39140 }
39141 {
39142 PyThreadState* __tstate = wxPyBeginAllowThreads();
39143 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39144
39145 wxPyEndAllowThreads(__tstate);
39146 if (PyErr_Occurred()) SWIG_fail;
39147 }
39148 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39149 return resultobj;
39150 fail:
39151 return NULL;
39152 }
39153
39154
39155 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39156 PyObject *resultobj;
39157 wxSizer *arg1 = (wxSizer *) 0 ;
39158 PyObject *arg2 = (PyObject *) 0 ;
39159 int arg3 = (int) 0 ;
39160 int arg4 = (int) 0 ;
39161 int arg5 = (int) 0 ;
39162 PyObject *arg6 = (PyObject *) NULL ;
39163 wxSizerItem *result;
39164 PyObject * obj0 = 0 ;
39165 PyObject * obj1 = 0 ;
39166 PyObject * obj2 = 0 ;
39167 PyObject * obj3 = 0 ;
39168 PyObject * obj4 = 0 ;
39169 PyObject * obj5 = 0 ;
39170 char *kwnames[] = {
39171 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39172 };
39173
39174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39176 if (SWIG_arg_fail(1)) SWIG_fail;
39177 arg2 = obj1;
39178 if (obj2) {
39179 {
39180 arg3 = (int)(SWIG_As_int(obj2));
39181 if (SWIG_arg_fail(3)) SWIG_fail;
39182 }
39183 }
39184 if (obj3) {
39185 {
39186 arg4 = (int)(SWIG_As_int(obj3));
39187 if (SWIG_arg_fail(4)) SWIG_fail;
39188 }
39189 }
39190 if (obj4) {
39191 {
39192 arg5 = (int)(SWIG_As_int(obj4));
39193 if (SWIG_arg_fail(5)) SWIG_fail;
39194 }
39195 }
39196 if (obj5) {
39197 arg6 = obj5;
39198 }
39199 {
39200 PyThreadState* __tstate = wxPyBeginAllowThreads();
39201 result = (wxSizerItem *)wxSizer_Prepend(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, 0);
39207 return resultobj;
39208 fail:
39209 return NULL;
39210 }
39211
39212
39213 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39214 PyObject *resultobj;
39215 wxSizer *arg1 = (wxSizer *) 0 ;
39216 PyObject *arg2 = (PyObject *) 0 ;
39217 bool result;
39218 PyObject * obj0 = 0 ;
39219 PyObject * obj1 = 0 ;
39220 char *kwnames[] = {
39221 (char *) "self",(char *) "item", NULL
39222 };
39223
39224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39226 if (SWIG_arg_fail(1)) SWIG_fail;
39227 arg2 = obj1;
39228 {
39229 PyThreadState* __tstate = wxPyBeginAllowThreads();
39230 result = (bool)wxSizer_Remove(arg1,arg2);
39231
39232 wxPyEndAllowThreads(__tstate);
39233 if (PyErr_Occurred()) SWIG_fail;
39234 }
39235 {
39236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39237 }
39238 return resultobj;
39239 fail:
39240 return NULL;
39241 }
39242
39243
39244 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39245 PyObject *resultobj;
39246 wxSizer *arg1 = (wxSizer *) 0 ;
39247 PyObject *arg2 = (PyObject *) 0 ;
39248 bool result;
39249 PyObject * obj0 = 0 ;
39250 PyObject * obj1 = 0 ;
39251 char *kwnames[] = {
39252 (char *) "self",(char *) "item", NULL
39253 };
39254
39255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39257 if (SWIG_arg_fail(1)) SWIG_fail;
39258 arg2 = obj1;
39259 {
39260 PyThreadState* __tstate = wxPyBeginAllowThreads();
39261 result = (bool)wxSizer_Detach(arg1,arg2);
39262
39263 wxPyEndAllowThreads(__tstate);
39264 if (PyErr_Occurred()) SWIG_fail;
39265 }
39266 {
39267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39268 }
39269 return resultobj;
39270 fail:
39271 return NULL;
39272 }
39273
39274
39275 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39276 PyObject *resultobj;
39277 wxSizer *arg1 = (wxSizer *) 0 ;
39278 PyObject *arg2 = (PyObject *) 0 ;
39279 wxSizerItem *result;
39280 PyObject * obj0 = 0 ;
39281 PyObject * obj1 = 0 ;
39282 char *kwnames[] = {
39283 (char *) "self",(char *) "item", NULL
39284 };
39285
39286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39288 if (SWIG_arg_fail(1)) SWIG_fail;
39289 arg2 = obj1;
39290 {
39291 PyThreadState* __tstate = wxPyBeginAllowThreads();
39292 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39293
39294 wxPyEndAllowThreads(__tstate);
39295 if (PyErr_Occurred()) SWIG_fail;
39296 }
39297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39298 return resultobj;
39299 fail:
39300 return NULL;
39301 }
39302
39303
39304 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39305 PyObject *resultobj;
39306 wxSizer *arg1 = (wxSizer *) 0 ;
39307 PyObject *arg2 = (PyObject *) 0 ;
39308 wxSize *arg3 = 0 ;
39309 wxSize temp3 ;
39310 PyObject * obj0 = 0 ;
39311 PyObject * obj1 = 0 ;
39312 PyObject * obj2 = 0 ;
39313 char *kwnames[] = {
39314 (char *) "self",(char *) "item",(char *) "size", NULL
39315 };
39316
39317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39319 if (SWIG_arg_fail(1)) SWIG_fail;
39320 arg2 = obj1;
39321 {
39322 arg3 = &temp3;
39323 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39324 }
39325 {
39326 PyThreadState* __tstate = wxPyBeginAllowThreads();
39327 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39328
39329 wxPyEndAllowThreads(__tstate);
39330 if (PyErr_Occurred()) SWIG_fail;
39331 }
39332 Py_INCREF(Py_None); resultobj = Py_None;
39333 return resultobj;
39334 fail:
39335 return NULL;
39336 }
39337
39338
39339 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39340 PyObject *resultobj;
39341 wxSizer *arg1 = (wxSizer *) 0 ;
39342 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39343 wxSizerItem *result;
39344 PyObject * obj0 = 0 ;
39345 PyObject * obj1 = 0 ;
39346 char *kwnames[] = {
39347 (char *) "self",(char *) "item", NULL
39348 };
39349
39350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39352 if (SWIG_arg_fail(1)) SWIG_fail;
39353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39354 if (SWIG_arg_fail(2)) SWIG_fail;
39355 {
39356 PyThreadState* __tstate = wxPyBeginAllowThreads();
39357 result = (wxSizerItem *)(arg1)->Add(arg2);
39358
39359 wxPyEndAllowThreads(__tstate);
39360 if (PyErr_Occurred()) SWIG_fail;
39361 }
39362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39363 return resultobj;
39364 fail:
39365 return NULL;
39366 }
39367
39368
39369 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39370 PyObject *resultobj;
39371 wxSizer *arg1 = (wxSizer *) 0 ;
39372 size_t arg2 ;
39373 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39374 wxSizerItem *result;
39375 PyObject * obj0 = 0 ;
39376 PyObject * obj1 = 0 ;
39377 PyObject * obj2 = 0 ;
39378 char *kwnames[] = {
39379 (char *) "self",(char *) "index",(char *) "item", NULL
39380 };
39381
39382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39384 if (SWIG_arg_fail(1)) SWIG_fail;
39385 {
39386 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39387 if (SWIG_arg_fail(2)) SWIG_fail;
39388 }
39389 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39390 if (SWIG_arg_fail(3)) SWIG_fail;
39391 {
39392 PyThreadState* __tstate = wxPyBeginAllowThreads();
39393 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39394
39395 wxPyEndAllowThreads(__tstate);
39396 if (PyErr_Occurred()) SWIG_fail;
39397 }
39398 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39399 return resultobj;
39400 fail:
39401 return NULL;
39402 }
39403
39404
39405 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39406 PyObject *resultobj;
39407 wxSizer *arg1 = (wxSizer *) 0 ;
39408 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39409 wxSizerItem *result;
39410 PyObject * obj0 = 0 ;
39411 PyObject * obj1 = 0 ;
39412 char *kwnames[] = {
39413 (char *) "self",(char *) "item", NULL
39414 };
39415
39416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39418 if (SWIG_arg_fail(1)) SWIG_fail;
39419 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39420 if (SWIG_arg_fail(2)) SWIG_fail;
39421 {
39422 PyThreadState* __tstate = wxPyBeginAllowThreads();
39423 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39424
39425 wxPyEndAllowThreads(__tstate);
39426 if (PyErr_Occurred()) SWIG_fail;
39427 }
39428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39429 return resultobj;
39430 fail:
39431 return NULL;
39432 }
39433
39434
39435 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39436 PyObject *resultobj;
39437 wxSizer *arg1 = (wxSizer *) 0 ;
39438 int arg2 ;
39439 int arg3 ;
39440 int arg4 ;
39441 int arg5 ;
39442 PyObject * obj0 = 0 ;
39443 PyObject * obj1 = 0 ;
39444 PyObject * obj2 = 0 ;
39445 PyObject * obj3 = 0 ;
39446 PyObject * obj4 = 0 ;
39447 char *kwnames[] = {
39448 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39449 };
39450
39451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39453 if (SWIG_arg_fail(1)) SWIG_fail;
39454 {
39455 arg2 = (int)(SWIG_As_int(obj1));
39456 if (SWIG_arg_fail(2)) SWIG_fail;
39457 }
39458 {
39459 arg3 = (int)(SWIG_As_int(obj2));
39460 if (SWIG_arg_fail(3)) SWIG_fail;
39461 }
39462 {
39463 arg4 = (int)(SWIG_As_int(obj3));
39464 if (SWIG_arg_fail(4)) SWIG_fail;
39465 }
39466 {
39467 arg5 = (int)(SWIG_As_int(obj4));
39468 if (SWIG_arg_fail(5)) SWIG_fail;
39469 }
39470 {
39471 PyThreadState* __tstate = wxPyBeginAllowThreads();
39472 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39473
39474 wxPyEndAllowThreads(__tstate);
39475 if (PyErr_Occurred()) SWIG_fail;
39476 }
39477 Py_INCREF(Py_None); resultobj = Py_None;
39478 return resultobj;
39479 fail:
39480 return NULL;
39481 }
39482
39483
39484 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39485 PyObject *resultobj;
39486 wxSizer *arg1 = (wxSizer *) 0 ;
39487 wxSize *arg2 = 0 ;
39488 wxSize temp2 ;
39489 PyObject * obj0 = 0 ;
39490 PyObject * obj1 = 0 ;
39491 char *kwnames[] = {
39492 (char *) "self",(char *) "size", NULL
39493 };
39494
39495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39497 if (SWIG_arg_fail(1)) SWIG_fail;
39498 {
39499 arg2 = &temp2;
39500 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39501 }
39502 {
39503 PyThreadState* __tstate = wxPyBeginAllowThreads();
39504 (arg1)->SetMinSize((wxSize const &)*arg2);
39505
39506 wxPyEndAllowThreads(__tstate);
39507 if (PyErr_Occurred()) SWIG_fail;
39508 }
39509 Py_INCREF(Py_None); resultobj = Py_None;
39510 return resultobj;
39511 fail:
39512 return NULL;
39513 }
39514
39515
39516 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39517 PyObject *resultobj;
39518 wxSizer *arg1 = (wxSizer *) 0 ;
39519 wxSize result;
39520 PyObject * obj0 = 0 ;
39521 char *kwnames[] = {
39522 (char *) "self", NULL
39523 };
39524
39525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
39526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39527 if (SWIG_arg_fail(1)) SWIG_fail;
39528 {
39529 PyThreadState* __tstate = wxPyBeginAllowThreads();
39530 result = (arg1)->GetSize();
39531
39532 wxPyEndAllowThreads(__tstate);
39533 if (PyErr_Occurred()) SWIG_fail;
39534 }
39535 {
39536 wxSize * resultptr;
39537 resultptr = new wxSize((wxSize &)(result));
39538 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39539 }
39540 return resultobj;
39541 fail:
39542 return NULL;
39543 }
39544
39545
39546 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39547 PyObject *resultobj;
39548 wxSizer *arg1 = (wxSizer *) 0 ;
39549 wxPoint result;
39550 PyObject * obj0 = 0 ;
39551 char *kwnames[] = {
39552 (char *) "self", NULL
39553 };
39554
39555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
39556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39557 if (SWIG_arg_fail(1)) SWIG_fail;
39558 {
39559 PyThreadState* __tstate = wxPyBeginAllowThreads();
39560 result = (arg1)->GetPosition();
39561
39562 wxPyEndAllowThreads(__tstate);
39563 if (PyErr_Occurred()) SWIG_fail;
39564 }
39565 {
39566 wxPoint * resultptr;
39567 resultptr = new wxPoint((wxPoint &)(result));
39568 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39569 }
39570 return resultobj;
39571 fail:
39572 return NULL;
39573 }
39574
39575
39576 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39577 PyObject *resultobj;
39578 wxSizer *arg1 = (wxSizer *) 0 ;
39579 wxSize result;
39580 PyObject * obj0 = 0 ;
39581 char *kwnames[] = {
39582 (char *) "self", NULL
39583 };
39584
39585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
39586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39587 if (SWIG_arg_fail(1)) SWIG_fail;
39588 {
39589 PyThreadState* __tstate = wxPyBeginAllowThreads();
39590 result = (arg1)->GetMinSize();
39591
39592 wxPyEndAllowThreads(__tstate);
39593 if (PyErr_Occurred()) SWIG_fail;
39594 }
39595 {
39596 wxSize * resultptr;
39597 resultptr = new wxSize((wxSize &)(result));
39598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39599 }
39600 return resultobj;
39601 fail:
39602 return NULL;
39603 }
39604
39605
39606 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
39607 PyObject *resultobj;
39608 wxSizer *arg1 = (wxSizer *) 0 ;
39609 PyObject * obj0 = 0 ;
39610 char *kwnames[] = {
39611 (char *) "self", NULL
39612 };
39613
39614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39616 if (SWIG_arg_fail(1)) SWIG_fail;
39617 {
39618 PyThreadState* __tstate = wxPyBeginAllowThreads();
39619 (arg1)->RecalcSizes();
39620
39621 wxPyEndAllowThreads(__tstate);
39622 if (PyErr_Occurred()) SWIG_fail;
39623 }
39624 Py_INCREF(Py_None); resultobj = Py_None;
39625 return resultobj;
39626 fail:
39627 return NULL;
39628 }
39629
39630
39631 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39632 PyObject *resultobj;
39633 wxSizer *arg1 = (wxSizer *) 0 ;
39634 wxSize result;
39635 PyObject * obj0 = 0 ;
39636 char *kwnames[] = {
39637 (char *) "self", NULL
39638 };
39639
39640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39642 if (SWIG_arg_fail(1)) SWIG_fail;
39643 {
39644 PyThreadState* __tstate = wxPyBeginAllowThreads();
39645 result = (arg1)->CalcMin();
39646
39647 wxPyEndAllowThreads(__tstate);
39648 if (PyErr_Occurred()) SWIG_fail;
39649 }
39650 {
39651 wxSize * resultptr;
39652 resultptr = new wxSize((wxSize &)(result));
39653 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39654 }
39655 return resultobj;
39656 fail:
39657 return NULL;
39658 }
39659
39660
39661 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39662 PyObject *resultobj;
39663 wxSizer *arg1 = (wxSizer *) 0 ;
39664 PyObject * obj0 = 0 ;
39665 char *kwnames[] = {
39666 (char *) "self", NULL
39667 };
39668
39669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39671 if (SWIG_arg_fail(1)) SWIG_fail;
39672 {
39673 PyThreadState* __tstate = wxPyBeginAllowThreads();
39674 (arg1)->Layout();
39675
39676 wxPyEndAllowThreads(__tstate);
39677 if (PyErr_Occurred()) SWIG_fail;
39678 }
39679 Py_INCREF(Py_None); resultobj = Py_None;
39680 return resultobj;
39681 fail:
39682 return NULL;
39683 }
39684
39685
39686 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39687 PyObject *resultobj;
39688 wxSizer *arg1 = (wxSizer *) 0 ;
39689 wxWindow *arg2 = (wxWindow *) 0 ;
39690 wxSize result;
39691 PyObject * obj0 = 0 ;
39692 PyObject * obj1 = 0 ;
39693 char *kwnames[] = {
39694 (char *) "self",(char *) "window", NULL
39695 };
39696
39697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39699 if (SWIG_arg_fail(1)) SWIG_fail;
39700 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39701 if (SWIG_arg_fail(2)) SWIG_fail;
39702 {
39703 PyThreadState* __tstate = wxPyBeginAllowThreads();
39704 result = (arg1)->Fit(arg2);
39705
39706 wxPyEndAllowThreads(__tstate);
39707 if (PyErr_Occurred()) SWIG_fail;
39708 }
39709 {
39710 wxSize * resultptr;
39711 resultptr = new wxSize((wxSize &)(result));
39712 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39713 }
39714 return resultobj;
39715 fail:
39716 return NULL;
39717 }
39718
39719
39720 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39721 PyObject *resultobj;
39722 wxSizer *arg1 = (wxSizer *) 0 ;
39723 wxWindow *arg2 = (wxWindow *) 0 ;
39724 PyObject * obj0 = 0 ;
39725 PyObject * obj1 = 0 ;
39726 char *kwnames[] = {
39727 (char *) "self",(char *) "window", NULL
39728 };
39729
39730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39732 if (SWIG_arg_fail(1)) SWIG_fail;
39733 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39734 if (SWIG_arg_fail(2)) SWIG_fail;
39735 {
39736 PyThreadState* __tstate = wxPyBeginAllowThreads();
39737 (arg1)->FitInside(arg2);
39738
39739 wxPyEndAllowThreads(__tstate);
39740 if (PyErr_Occurred()) SWIG_fail;
39741 }
39742 Py_INCREF(Py_None); resultobj = Py_None;
39743 return resultobj;
39744 fail:
39745 return NULL;
39746 }
39747
39748
39749 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39750 PyObject *resultobj;
39751 wxSizer *arg1 = (wxSizer *) 0 ;
39752 wxWindow *arg2 = (wxWindow *) 0 ;
39753 PyObject * obj0 = 0 ;
39754 PyObject * obj1 = 0 ;
39755 char *kwnames[] = {
39756 (char *) "self",(char *) "window", NULL
39757 };
39758
39759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39761 if (SWIG_arg_fail(1)) SWIG_fail;
39762 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39763 if (SWIG_arg_fail(2)) SWIG_fail;
39764 {
39765 PyThreadState* __tstate = wxPyBeginAllowThreads();
39766 (arg1)->SetSizeHints(arg2);
39767
39768 wxPyEndAllowThreads(__tstate);
39769 if (PyErr_Occurred()) SWIG_fail;
39770 }
39771 Py_INCREF(Py_None); resultobj = Py_None;
39772 return resultobj;
39773 fail:
39774 return NULL;
39775 }
39776
39777
39778 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39779 PyObject *resultobj;
39780 wxSizer *arg1 = (wxSizer *) 0 ;
39781 wxWindow *arg2 = (wxWindow *) 0 ;
39782 PyObject * obj0 = 0 ;
39783 PyObject * obj1 = 0 ;
39784 char *kwnames[] = {
39785 (char *) "self",(char *) "window", NULL
39786 };
39787
39788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39790 if (SWIG_arg_fail(1)) SWIG_fail;
39791 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39792 if (SWIG_arg_fail(2)) SWIG_fail;
39793 {
39794 PyThreadState* __tstate = wxPyBeginAllowThreads();
39795 (arg1)->SetVirtualSizeHints(arg2);
39796
39797 wxPyEndAllowThreads(__tstate);
39798 if (PyErr_Occurred()) SWIG_fail;
39799 }
39800 Py_INCREF(Py_None); resultobj = Py_None;
39801 return resultobj;
39802 fail:
39803 return NULL;
39804 }
39805
39806
39807 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39808 PyObject *resultobj;
39809 wxSizer *arg1 = (wxSizer *) 0 ;
39810 bool arg2 = (bool) false ;
39811 PyObject * obj0 = 0 ;
39812 PyObject * obj1 = 0 ;
39813 char *kwnames[] = {
39814 (char *) "self",(char *) "deleteWindows", NULL
39815 };
39816
39817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39819 if (SWIG_arg_fail(1)) SWIG_fail;
39820 if (obj1) {
39821 {
39822 arg2 = (bool)(SWIG_As_bool(obj1));
39823 if (SWIG_arg_fail(2)) SWIG_fail;
39824 }
39825 }
39826 {
39827 PyThreadState* __tstate = wxPyBeginAllowThreads();
39828 (arg1)->Clear(arg2);
39829
39830 wxPyEndAllowThreads(__tstate);
39831 if (PyErr_Occurred()) SWIG_fail;
39832 }
39833 Py_INCREF(Py_None); resultobj = Py_None;
39834 return resultobj;
39835 fail:
39836 return NULL;
39837 }
39838
39839
39840 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39841 PyObject *resultobj;
39842 wxSizer *arg1 = (wxSizer *) 0 ;
39843 PyObject * obj0 = 0 ;
39844 char *kwnames[] = {
39845 (char *) "self", NULL
39846 };
39847
39848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39850 if (SWIG_arg_fail(1)) SWIG_fail;
39851 {
39852 PyThreadState* __tstate = wxPyBeginAllowThreads();
39853 (arg1)->DeleteWindows();
39854
39855 wxPyEndAllowThreads(__tstate);
39856 if (PyErr_Occurred()) SWIG_fail;
39857 }
39858 Py_INCREF(Py_None); resultobj = Py_None;
39859 return resultobj;
39860 fail:
39861 return NULL;
39862 }
39863
39864
39865 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39866 PyObject *resultobj;
39867 wxSizer *arg1 = (wxSizer *) 0 ;
39868 PyObject *result;
39869 PyObject * obj0 = 0 ;
39870 char *kwnames[] = {
39871 (char *) "self", NULL
39872 };
39873
39874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39876 if (SWIG_arg_fail(1)) SWIG_fail;
39877 {
39878 PyThreadState* __tstate = wxPyBeginAllowThreads();
39879 result = (PyObject *)wxSizer_GetChildren(arg1);
39880
39881 wxPyEndAllowThreads(__tstate);
39882 if (PyErr_Occurred()) SWIG_fail;
39883 }
39884 resultobj = result;
39885 return resultobj;
39886 fail:
39887 return NULL;
39888 }
39889
39890
39891 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39892 PyObject *resultobj;
39893 wxSizer *arg1 = (wxSizer *) 0 ;
39894 PyObject *arg2 = (PyObject *) 0 ;
39895 bool arg3 = (bool) true ;
39896 bool arg4 = (bool) false ;
39897 bool result;
39898 PyObject * obj0 = 0 ;
39899 PyObject * obj1 = 0 ;
39900 PyObject * obj2 = 0 ;
39901 PyObject * obj3 = 0 ;
39902 char *kwnames[] = {
39903 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39904 };
39905
39906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39908 if (SWIG_arg_fail(1)) SWIG_fail;
39909 arg2 = obj1;
39910 if (obj2) {
39911 {
39912 arg3 = (bool)(SWIG_As_bool(obj2));
39913 if (SWIG_arg_fail(3)) SWIG_fail;
39914 }
39915 }
39916 if (obj3) {
39917 {
39918 arg4 = (bool)(SWIG_As_bool(obj3));
39919 if (SWIG_arg_fail(4)) SWIG_fail;
39920 }
39921 }
39922 {
39923 PyThreadState* __tstate = wxPyBeginAllowThreads();
39924 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39925
39926 wxPyEndAllowThreads(__tstate);
39927 if (PyErr_Occurred()) SWIG_fail;
39928 }
39929 {
39930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39931 }
39932 return resultobj;
39933 fail:
39934 return NULL;
39935 }
39936
39937
39938 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39939 PyObject *resultobj;
39940 wxSizer *arg1 = (wxSizer *) 0 ;
39941 PyObject *arg2 = (PyObject *) 0 ;
39942 bool result;
39943 PyObject * obj0 = 0 ;
39944 PyObject * obj1 = 0 ;
39945 char *kwnames[] = {
39946 (char *) "self",(char *) "item", NULL
39947 };
39948
39949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39951 if (SWIG_arg_fail(1)) SWIG_fail;
39952 arg2 = obj1;
39953 {
39954 PyThreadState* __tstate = wxPyBeginAllowThreads();
39955 result = (bool)wxSizer_IsShown(arg1,arg2);
39956
39957 wxPyEndAllowThreads(__tstate);
39958 if (PyErr_Occurred()) SWIG_fail;
39959 }
39960 {
39961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39962 }
39963 return resultobj;
39964 fail:
39965 return NULL;
39966 }
39967
39968
39969 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39970 PyObject *resultobj;
39971 wxSizer *arg1 = (wxSizer *) 0 ;
39972 bool arg2 ;
39973 PyObject * obj0 = 0 ;
39974 PyObject * obj1 = 0 ;
39975 char *kwnames[] = {
39976 (char *) "self",(char *) "show", NULL
39977 };
39978
39979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39981 if (SWIG_arg_fail(1)) SWIG_fail;
39982 {
39983 arg2 = (bool)(SWIG_As_bool(obj1));
39984 if (SWIG_arg_fail(2)) SWIG_fail;
39985 }
39986 {
39987 PyThreadState* __tstate = wxPyBeginAllowThreads();
39988 (arg1)->ShowItems(arg2);
39989
39990 wxPyEndAllowThreads(__tstate);
39991 if (PyErr_Occurred()) SWIG_fail;
39992 }
39993 Py_INCREF(Py_None); resultobj = Py_None;
39994 return resultobj;
39995 fail:
39996 return NULL;
39997 }
39998
39999
40000 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40001 PyObject *obj;
40002 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40003 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40004 Py_INCREF(obj);
40005 return Py_BuildValue((char *)"");
40006 }
40007 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40008 PyObject *resultobj;
40009 wxPySizer *result;
40010 char *kwnames[] = {
40011 NULL
40012 };
40013
40014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40015 {
40016 PyThreadState* __tstate = wxPyBeginAllowThreads();
40017 result = (wxPySizer *)new wxPySizer();
40018
40019 wxPyEndAllowThreads(__tstate);
40020 if (PyErr_Occurred()) SWIG_fail;
40021 }
40022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40023 return resultobj;
40024 fail:
40025 return NULL;
40026 }
40027
40028
40029 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40030 PyObject *resultobj;
40031 wxPySizer *arg1 = (wxPySizer *) 0 ;
40032 PyObject *arg2 = (PyObject *) 0 ;
40033 PyObject *arg3 = (PyObject *) 0 ;
40034 PyObject * obj0 = 0 ;
40035 PyObject * obj1 = 0 ;
40036 PyObject * obj2 = 0 ;
40037 char *kwnames[] = {
40038 (char *) "self",(char *) "self",(char *) "_class", NULL
40039 };
40040
40041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40043 if (SWIG_arg_fail(1)) SWIG_fail;
40044 arg2 = obj1;
40045 arg3 = obj2;
40046 {
40047 PyThreadState* __tstate = wxPyBeginAllowThreads();
40048 (arg1)->_setCallbackInfo(arg2,arg3);
40049
40050 wxPyEndAllowThreads(__tstate);
40051 if (PyErr_Occurred()) SWIG_fail;
40052 }
40053 Py_INCREF(Py_None); resultobj = Py_None;
40054 return resultobj;
40055 fail:
40056 return NULL;
40057 }
40058
40059
40060 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40061 PyObject *obj;
40062 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40063 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40064 Py_INCREF(obj);
40065 return Py_BuildValue((char *)"");
40066 }
40067 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40068 PyObject *resultobj;
40069 int arg1 = (int) wxHORIZONTAL ;
40070 wxBoxSizer *result;
40071 PyObject * obj0 = 0 ;
40072 char *kwnames[] = {
40073 (char *) "orient", NULL
40074 };
40075
40076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40077 if (obj0) {
40078 {
40079 arg1 = (int)(SWIG_As_int(obj0));
40080 if (SWIG_arg_fail(1)) SWIG_fail;
40081 }
40082 }
40083 {
40084 PyThreadState* __tstate = wxPyBeginAllowThreads();
40085 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40086
40087 wxPyEndAllowThreads(__tstate);
40088 if (PyErr_Occurred()) SWIG_fail;
40089 }
40090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40091 return resultobj;
40092 fail:
40093 return NULL;
40094 }
40095
40096
40097 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40098 PyObject *resultobj;
40099 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40100 int result;
40101 PyObject * obj0 = 0 ;
40102 char *kwnames[] = {
40103 (char *) "self", NULL
40104 };
40105
40106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40108 if (SWIG_arg_fail(1)) SWIG_fail;
40109 {
40110 PyThreadState* __tstate = wxPyBeginAllowThreads();
40111 result = (int)(arg1)->GetOrientation();
40112
40113 wxPyEndAllowThreads(__tstate);
40114 if (PyErr_Occurred()) SWIG_fail;
40115 }
40116 {
40117 resultobj = SWIG_From_int((int)(result));
40118 }
40119 return resultobj;
40120 fail:
40121 return NULL;
40122 }
40123
40124
40125 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40126 PyObject *resultobj;
40127 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40128 int arg2 ;
40129 PyObject * obj0 = 0 ;
40130 PyObject * obj1 = 0 ;
40131 char *kwnames[] = {
40132 (char *) "self",(char *) "orient", NULL
40133 };
40134
40135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40137 if (SWIG_arg_fail(1)) SWIG_fail;
40138 {
40139 arg2 = (int)(SWIG_As_int(obj1));
40140 if (SWIG_arg_fail(2)) SWIG_fail;
40141 }
40142 {
40143 PyThreadState* __tstate = wxPyBeginAllowThreads();
40144 (arg1)->SetOrientation(arg2);
40145
40146 wxPyEndAllowThreads(__tstate);
40147 if (PyErr_Occurred()) SWIG_fail;
40148 }
40149 Py_INCREF(Py_None); resultobj = Py_None;
40150 return resultobj;
40151 fail:
40152 return NULL;
40153 }
40154
40155
40156 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40157 PyObject *obj;
40158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40159 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40160 Py_INCREF(obj);
40161 return Py_BuildValue((char *)"");
40162 }
40163 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40164 PyObject *resultobj;
40165 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40166 int arg2 = (int) wxHORIZONTAL ;
40167 wxStaticBoxSizer *result;
40168 PyObject * obj0 = 0 ;
40169 PyObject * obj1 = 0 ;
40170 char *kwnames[] = {
40171 (char *) "box",(char *) "orient", NULL
40172 };
40173
40174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40176 if (SWIG_arg_fail(1)) SWIG_fail;
40177 if (obj1) {
40178 {
40179 arg2 = (int)(SWIG_As_int(obj1));
40180 if (SWIG_arg_fail(2)) SWIG_fail;
40181 }
40182 }
40183 {
40184 PyThreadState* __tstate = wxPyBeginAllowThreads();
40185 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40186
40187 wxPyEndAllowThreads(__tstate);
40188 if (PyErr_Occurred()) SWIG_fail;
40189 }
40190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40191 return resultobj;
40192 fail:
40193 return NULL;
40194 }
40195
40196
40197 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40198 PyObject *resultobj;
40199 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40200 wxStaticBox *result;
40201 PyObject * obj0 = 0 ;
40202 char *kwnames[] = {
40203 (char *) "self", NULL
40204 };
40205
40206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40208 if (SWIG_arg_fail(1)) SWIG_fail;
40209 {
40210 PyThreadState* __tstate = wxPyBeginAllowThreads();
40211 result = (wxStaticBox *)(arg1)->GetStaticBox();
40212
40213 wxPyEndAllowThreads(__tstate);
40214 if (PyErr_Occurred()) SWIG_fail;
40215 }
40216 {
40217 resultobj = wxPyMake_wxObject(result, 0);
40218 }
40219 return resultobj;
40220 fail:
40221 return NULL;
40222 }
40223
40224
40225 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40226 PyObject *obj;
40227 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40228 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40229 Py_INCREF(obj);
40230 return Py_BuildValue((char *)"");
40231 }
40232 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40233 PyObject *resultobj;
40234 int arg1 = (int) 1 ;
40235 int arg2 = (int) 0 ;
40236 int arg3 = (int) 0 ;
40237 int arg4 = (int) 0 ;
40238 wxGridSizer *result;
40239 PyObject * obj0 = 0 ;
40240 PyObject * obj1 = 0 ;
40241 PyObject * obj2 = 0 ;
40242 PyObject * obj3 = 0 ;
40243 char *kwnames[] = {
40244 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40245 };
40246
40247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40248 if (obj0) {
40249 {
40250 arg1 = (int)(SWIG_As_int(obj0));
40251 if (SWIG_arg_fail(1)) SWIG_fail;
40252 }
40253 }
40254 if (obj1) {
40255 {
40256 arg2 = (int)(SWIG_As_int(obj1));
40257 if (SWIG_arg_fail(2)) SWIG_fail;
40258 }
40259 }
40260 if (obj2) {
40261 {
40262 arg3 = (int)(SWIG_As_int(obj2));
40263 if (SWIG_arg_fail(3)) SWIG_fail;
40264 }
40265 }
40266 if (obj3) {
40267 {
40268 arg4 = (int)(SWIG_As_int(obj3));
40269 if (SWIG_arg_fail(4)) SWIG_fail;
40270 }
40271 }
40272 {
40273 PyThreadState* __tstate = wxPyBeginAllowThreads();
40274 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40275
40276 wxPyEndAllowThreads(__tstate);
40277 if (PyErr_Occurred()) SWIG_fail;
40278 }
40279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40280 return resultobj;
40281 fail:
40282 return NULL;
40283 }
40284
40285
40286 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40287 PyObject *resultobj;
40288 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40289 int arg2 ;
40290 PyObject * obj0 = 0 ;
40291 PyObject * obj1 = 0 ;
40292 char *kwnames[] = {
40293 (char *) "self",(char *) "cols", NULL
40294 };
40295
40296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40298 if (SWIG_arg_fail(1)) SWIG_fail;
40299 {
40300 arg2 = (int)(SWIG_As_int(obj1));
40301 if (SWIG_arg_fail(2)) SWIG_fail;
40302 }
40303 {
40304 PyThreadState* __tstate = wxPyBeginAllowThreads();
40305 (arg1)->SetCols(arg2);
40306
40307 wxPyEndAllowThreads(__tstate);
40308 if (PyErr_Occurred()) SWIG_fail;
40309 }
40310 Py_INCREF(Py_None); resultobj = Py_None;
40311 return resultobj;
40312 fail:
40313 return NULL;
40314 }
40315
40316
40317 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40318 PyObject *resultobj;
40319 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40320 int arg2 ;
40321 PyObject * obj0 = 0 ;
40322 PyObject * obj1 = 0 ;
40323 char *kwnames[] = {
40324 (char *) "self",(char *) "rows", NULL
40325 };
40326
40327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40329 if (SWIG_arg_fail(1)) SWIG_fail;
40330 {
40331 arg2 = (int)(SWIG_As_int(obj1));
40332 if (SWIG_arg_fail(2)) SWIG_fail;
40333 }
40334 {
40335 PyThreadState* __tstate = wxPyBeginAllowThreads();
40336 (arg1)->SetRows(arg2);
40337
40338 wxPyEndAllowThreads(__tstate);
40339 if (PyErr_Occurred()) SWIG_fail;
40340 }
40341 Py_INCREF(Py_None); resultobj = Py_None;
40342 return resultobj;
40343 fail:
40344 return NULL;
40345 }
40346
40347
40348 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40349 PyObject *resultobj;
40350 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40351 int arg2 ;
40352 PyObject * obj0 = 0 ;
40353 PyObject * obj1 = 0 ;
40354 char *kwnames[] = {
40355 (char *) "self",(char *) "gap", NULL
40356 };
40357
40358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40360 if (SWIG_arg_fail(1)) SWIG_fail;
40361 {
40362 arg2 = (int)(SWIG_As_int(obj1));
40363 if (SWIG_arg_fail(2)) SWIG_fail;
40364 }
40365 {
40366 PyThreadState* __tstate = wxPyBeginAllowThreads();
40367 (arg1)->SetVGap(arg2);
40368
40369 wxPyEndAllowThreads(__tstate);
40370 if (PyErr_Occurred()) SWIG_fail;
40371 }
40372 Py_INCREF(Py_None); resultobj = Py_None;
40373 return resultobj;
40374 fail:
40375 return NULL;
40376 }
40377
40378
40379 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40380 PyObject *resultobj;
40381 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40382 int arg2 ;
40383 PyObject * obj0 = 0 ;
40384 PyObject * obj1 = 0 ;
40385 char *kwnames[] = {
40386 (char *) "self",(char *) "gap", NULL
40387 };
40388
40389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40391 if (SWIG_arg_fail(1)) SWIG_fail;
40392 {
40393 arg2 = (int)(SWIG_As_int(obj1));
40394 if (SWIG_arg_fail(2)) SWIG_fail;
40395 }
40396 {
40397 PyThreadState* __tstate = wxPyBeginAllowThreads();
40398 (arg1)->SetHGap(arg2);
40399
40400 wxPyEndAllowThreads(__tstate);
40401 if (PyErr_Occurred()) SWIG_fail;
40402 }
40403 Py_INCREF(Py_None); resultobj = Py_None;
40404 return resultobj;
40405 fail:
40406 return NULL;
40407 }
40408
40409
40410 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40411 PyObject *resultobj;
40412 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40413 int result;
40414 PyObject * obj0 = 0 ;
40415 char *kwnames[] = {
40416 (char *) "self", NULL
40417 };
40418
40419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40421 if (SWIG_arg_fail(1)) SWIG_fail;
40422 {
40423 PyThreadState* __tstate = wxPyBeginAllowThreads();
40424 result = (int)(arg1)->GetCols();
40425
40426 wxPyEndAllowThreads(__tstate);
40427 if (PyErr_Occurred()) SWIG_fail;
40428 }
40429 {
40430 resultobj = SWIG_From_int((int)(result));
40431 }
40432 return resultobj;
40433 fail:
40434 return NULL;
40435 }
40436
40437
40438 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40439 PyObject *resultobj;
40440 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40441 int result;
40442 PyObject * obj0 = 0 ;
40443 char *kwnames[] = {
40444 (char *) "self", NULL
40445 };
40446
40447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40449 if (SWIG_arg_fail(1)) SWIG_fail;
40450 {
40451 PyThreadState* __tstate = wxPyBeginAllowThreads();
40452 result = (int)(arg1)->GetRows();
40453
40454 wxPyEndAllowThreads(__tstate);
40455 if (PyErr_Occurred()) SWIG_fail;
40456 }
40457 {
40458 resultobj = SWIG_From_int((int)(result));
40459 }
40460 return resultobj;
40461 fail:
40462 return NULL;
40463 }
40464
40465
40466 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40467 PyObject *resultobj;
40468 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40469 int result;
40470 PyObject * obj0 = 0 ;
40471 char *kwnames[] = {
40472 (char *) "self", NULL
40473 };
40474
40475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40477 if (SWIG_arg_fail(1)) SWIG_fail;
40478 {
40479 PyThreadState* __tstate = wxPyBeginAllowThreads();
40480 result = (int)(arg1)->GetVGap();
40481
40482 wxPyEndAllowThreads(__tstate);
40483 if (PyErr_Occurred()) SWIG_fail;
40484 }
40485 {
40486 resultobj = SWIG_From_int((int)(result));
40487 }
40488 return resultobj;
40489 fail:
40490 return NULL;
40491 }
40492
40493
40494 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40495 PyObject *resultobj;
40496 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40497 int result;
40498 PyObject * obj0 = 0 ;
40499 char *kwnames[] = {
40500 (char *) "self", NULL
40501 };
40502
40503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40505 if (SWIG_arg_fail(1)) SWIG_fail;
40506 {
40507 PyThreadState* __tstate = wxPyBeginAllowThreads();
40508 result = (int)(arg1)->GetHGap();
40509
40510 wxPyEndAllowThreads(__tstate);
40511 if (PyErr_Occurred()) SWIG_fail;
40512 }
40513 {
40514 resultobj = SWIG_From_int((int)(result));
40515 }
40516 return resultobj;
40517 fail:
40518 return NULL;
40519 }
40520
40521
40522 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
40523 PyObject *obj;
40524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40525 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
40526 Py_INCREF(obj);
40527 return Py_BuildValue((char *)"");
40528 }
40529 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40530 PyObject *resultobj;
40531 int arg1 = (int) 1 ;
40532 int arg2 = (int) 0 ;
40533 int arg3 = (int) 0 ;
40534 int arg4 = (int) 0 ;
40535 wxFlexGridSizer *result;
40536 PyObject * obj0 = 0 ;
40537 PyObject * obj1 = 0 ;
40538 PyObject * obj2 = 0 ;
40539 PyObject * obj3 = 0 ;
40540 char *kwnames[] = {
40541 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40542 };
40543
40544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40545 if (obj0) {
40546 {
40547 arg1 = (int)(SWIG_As_int(obj0));
40548 if (SWIG_arg_fail(1)) SWIG_fail;
40549 }
40550 }
40551 if (obj1) {
40552 {
40553 arg2 = (int)(SWIG_As_int(obj1));
40554 if (SWIG_arg_fail(2)) SWIG_fail;
40555 }
40556 }
40557 if (obj2) {
40558 {
40559 arg3 = (int)(SWIG_As_int(obj2));
40560 if (SWIG_arg_fail(3)) SWIG_fail;
40561 }
40562 }
40563 if (obj3) {
40564 {
40565 arg4 = (int)(SWIG_As_int(obj3));
40566 if (SWIG_arg_fail(4)) SWIG_fail;
40567 }
40568 }
40569 {
40570 PyThreadState* __tstate = wxPyBeginAllowThreads();
40571 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
40572
40573 wxPyEndAllowThreads(__tstate);
40574 if (PyErr_Occurred()) SWIG_fail;
40575 }
40576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
40577 return resultobj;
40578 fail:
40579 return NULL;
40580 }
40581
40582
40583 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40584 PyObject *resultobj;
40585 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40586 size_t arg2 ;
40587 int arg3 = (int) 0 ;
40588 PyObject * obj0 = 0 ;
40589 PyObject * obj1 = 0 ;
40590 PyObject * obj2 = 0 ;
40591 char *kwnames[] = {
40592 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40593 };
40594
40595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
40596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40597 if (SWIG_arg_fail(1)) SWIG_fail;
40598 {
40599 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40600 if (SWIG_arg_fail(2)) SWIG_fail;
40601 }
40602 if (obj2) {
40603 {
40604 arg3 = (int)(SWIG_As_int(obj2));
40605 if (SWIG_arg_fail(3)) SWIG_fail;
40606 }
40607 }
40608 {
40609 PyThreadState* __tstate = wxPyBeginAllowThreads();
40610 (arg1)->AddGrowableRow(arg2,arg3);
40611
40612 wxPyEndAllowThreads(__tstate);
40613 if (PyErr_Occurred()) SWIG_fail;
40614 }
40615 Py_INCREF(Py_None); resultobj = Py_None;
40616 return resultobj;
40617 fail:
40618 return NULL;
40619 }
40620
40621
40622 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40623 PyObject *resultobj;
40624 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40625 size_t arg2 ;
40626 PyObject * obj0 = 0 ;
40627 PyObject * obj1 = 0 ;
40628 char *kwnames[] = {
40629 (char *) "self",(char *) "idx", NULL
40630 };
40631
40632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40634 if (SWIG_arg_fail(1)) SWIG_fail;
40635 {
40636 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40637 if (SWIG_arg_fail(2)) SWIG_fail;
40638 }
40639 {
40640 PyThreadState* __tstate = wxPyBeginAllowThreads();
40641 (arg1)->RemoveGrowableRow(arg2);
40642
40643 wxPyEndAllowThreads(__tstate);
40644 if (PyErr_Occurred()) SWIG_fail;
40645 }
40646 Py_INCREF(Py_None); resultobj = Py_None;
40647 return resultobj;
40648 fail:
40649 return NULL;
40650 }
40651
40652
40653 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40654 PyObject *resultobj;
40655 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40656 size_t arg2 ;
40657 int arg3 = (int) 0 ;
40658 PyObject * obj0 = 0 ;
40659 PyObject * obj1 = 0 ;
40660 PyObject * obj2 = 0 ;
40661 char *kwnames[] = {
40662 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40663 };
40664
40665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40667 if (SWIG_arg_fail(1)) SWIG_fail;
40668 {
40669 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40670 if (SWIG_arg_fail(2)) SWIG_fail;
40671 }
40672 if (obj2) {
40673 {
40674 arg3 = (int)(SWIG_As_int(obj2));
40675 if (SWIG_arg_fail(3)) SWIG_fail;
40676 }
40677 }
40678 {
40679 PyThreadState* __tstate = wxPyBeginAllowThreads();
40680 (arg1)->AddGrowableCol(arg2,arg3);
40681
40682 wxPyEndAllowThreads(__tstate);
40683 if (PyErr_Occurred()) SWIG_fail;
40684 }
40685 Py_INCREF(Py_None); resultobj = Py_None;
40686 return resultobj;
40687 fail:
40688 return NULL;
40689 }
40690
40691
40692 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40693 PyObject *resultobj;
40694 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40695 size_t arg2 ;
40696 PyObject * obj0 = 0 ;
40697 PyObject * obj1 = 0 ;
40698 char *kwnames[] = {
40699 (char *) "self",(char *) "idx", NULL
40700 };
40701
40702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40704 if (SWIG_arg_fail(1)) SWIG_fail;
40705 {
40706 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40707 if (SWIG_arg_fail(2)) SWIG_fail;
40708 }
40709 {
40710 PyThreadState* __tstate = wxPyBeginAllowThreads();
40711 (arg1)->RemoveGrowableCol(arg2);
40712
40713 wxPyEndAllowThreads(__tstate);
40714 if (PyErr_Occurred()) SWIG_fail;
40715 }
40716 Py_INCREF(Py_None); resultobj = Py_None;
40717 return resultobj;
40718 fail:
40719 return NULL;
40720 }
40721
40722
40723 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40724 PyObject *resultobj;
40725 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40726 int arg2 ;
40727 PyObject * obj0 = 0 ;
40728 PyObject * obj1 = 0 ;
40729 char *kwnames[] = {
40730 (char *) "self",(char *) "direction", NULL
40731 };
40732
40733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40735 if (SWIG_arg_fail(1)) SWIG_fail;
40736 {
40737 arg2 = (int)(SWIG_As_int(obj1));
40738 if (SWIG_arg_fail(2)) SWIG_fail;
40739 }
40740 {
40741 PyThreadState* __tstate = wxPyBeginAllowThreads();
40742 (arg1)->SetFlexibleDirection(arg2);
40743
40744 wxPyEndAllowThreads(__tstate);
40745 if (PyErr_Occurred()) SWIG_fail;
40746 }
40747 Py_INCREF(Py_None); resultobj = Py_None;
40748 return resultobj;
40749 fail:
40750 return NULL;
40751 }
40752
40753
40754 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40755 PyObject *resultobj;
40756 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40757 int result;
40758 PyObject * obj0 = 0 ;
40759 char *kwnames[] = {
40760 (char *) "self", NULL
40761 };
40762
40763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40765 if (SWIG_arg_fail(1)) SWIG_fail;
40766 {
40767 PyThreadState* __tstate = wxPyBeginAllowThreads();
40768 result = (int)(arg1)->GetFlexibleDirection();
40769
40770 wxPyEndAllowThreads(__tstate);
40771 if (PyErr_Occurred()) SWIG_fail;
40772 }
40773 {
40774 resultobj = SWIG_From_int((int)(result));
40775 }
40776 return resultobj;
40777 fail:
40778 return NULL;
40779 }
40780
40781
40782 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40783 PyObject *resultobj;
40784 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40785 wxFlexSizerGrowMode arg2 ;
40786 PyObject * obj0 = 0 ;
40787 PyObject * obj1 = 0 ;
40788 char *kwnames[] = {
40789 (char *) "self",(char *) "mode", NULL
40790 };
40791
40792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40794 if (SWIG_arg_fail(1)) SWIG_fail;
40795 {
40796 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40797 if (SWIG_arg_fail(2)) SWIG_fail;
40798 }
40799 {
40800 PyThreadState* __tstate = wxPyBeginAllowThreads();
40801 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40802
40803 wxPyEndAllowThreads(__tstate);
40804 if (PyErr_Occurred()) SWIG_fail;
40805 }
40806 Py_INCREF(Py_None); resultobj = Py_None;
40807 return resultobj;
40808 fail:
40809 return NULL;
40810 }
40811
40812
40813 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40814 PyObject *resultobj;
40815 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40816 wxFlexSizerGrowMode result;
40817 PyObject * obj0 = 0 ;
40818 char *kwnames[] = {
40819 (char *) "self", NULL
40820 };
40821
40822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40824 if (SWIG_arg_fail(1)) SWIG_fail;
40825 {
40826 PyThreadState* __tstate = wxPyBeginAllowThreads();
40827 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40828
40829 wxPyEndAllowThreads(__tstate);
40830 if (PyErr_Occurred()) SWIG_fail;
40831 }
40832 resultobj = SWIG_From_int((result));
40833 return resultobj;
40834 fail:
40835 return NULL;
40836 }
40837
40838
40839 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40840 PyObject *resultobj;
40841 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40842 wxArrayInt *result;
40843 PyObject * obj0 = 0 ;
40844 char *kwnames[] = {
40845 (char *) "self", NULL
40846 };
40847
40848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40850 if (SWIG_arg_fail(1)) SWIG_fail;
40851 {
40852 PyThreadState* __tstate = wxPyBeginAllowThreads();
40853 {
40854 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40855 result = (wxArrayInt *) &_result_ref;
40856 }
40857
40858 wxPyEndAllowThreads(__tstate);
40859 if (PyErr_Occurred()) SWIG_fail;
40860 }
40861 {
40862 resultobj = PyList_New(0);
40863 size_t idx;
40864 for (idx = 0; idx < result->GetCount(); idx += 1) {
40865 PyObject* val = PyInt_FromLong( result->Item(idx) );
40866 PyList_Append(resultobj, val);
40867 Py_DECREF(val);
40868 }
40869 }
40870 return resultobj;
40871 fail:
40872 return NULL;
40873 }
40874
40875
40876 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40877 PyObject *resultobj;
40878 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40879 wxArrayInt *result;
40880 PyObject * obj0 = 0 ;
40881 char *kwnames[] = {
40882 (char *) "self", NULL
40883 };
40884
40885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40887 if (SWIG_arg_fail(1)) SWIG_fail;
40888 {
40889 PyThreadState* __tstate = wxPyBeginAllowThreads();
40890 {
40891 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40892 result = (wxArrayInt *) &_result_ref;
40893 }
40894
40895 wxPyEndAllowThreads(__tstate);
40896 if (PyErr_Occurred()) SWIG_fail;
40897 }
40898 {
40899 resultobj = PyList_New(0);
40900 size_t idx;
40901 for (idx = 0; idx < result->GetCount(); idx += 1) {
40902 PyObject* val = PyInt_FromLong( result->Item(idx) );
40903 PyList_Append(resultobj, val);
40904 Py_DECREF(val);
40905 }
40906 }
40907 return resultobj;
40908 fail:
40909 return NULL;
40910 }
40911
40912
40913 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40914 PyObject *obj;
40915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40916 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40917 Py_INCREF(obj);
40918 return Py_BuildValue((char *)"");
40919 }
40920 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40921 PyObject *resultobj;
40922 wxStdDialogButtonSizer *result;
40923 char *kwnames[] = {
40924 NULL
40925 };
40926
40927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40928 {
40929 PyThreadState* __tstate = wxPyBeginAllowThreads();
40930 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40931
40932 wxPyEndAllowThreads(__tstate);
40933 if (PyErr_Occurred()) SWIG_fail;
40934 }
40935 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40936 return resultobj;
40937 fail:
40938 return NULL;
40939 }
40940
40941
40942 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40943 PyObject *resultobj;
40944 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40945 wxButton *arg2 = (wxButton *) 0 ;
40946 PyObject * obj0 = 0 ;
40947 PyObject * obj1 = 0 ;
40948 char *kwnames[] = {
40949 (char *) "self",(char *) "button", NULL
40950 };
40951
40952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40954 if (SWIG_arg_fail(1)) SWIG_fail;
40955 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40956 if (SWIG_arg_fail(2)) SWIG_fail;
40957 {
40958 PyThreadState* __tstate = wxPyBeginAllowThreads();
40959 (arg1)->AddButton(arg2);
40960
40961 wxPyEndAllowThreads(__tstate);
40962 if (PyErr_Occurred()) SWIG_fail;
40963 }
40964 Py_INCREF(Py_None); resultobj = Py_None;
40965 return resultobj;
40966 fail:
40967 return NULL;
40968 }
40969
40970
40971 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
40972 PyObject *resultobj;
40973 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40974 PyObject * obj0 = 0 ;
40975 char *kwnames[] = {
40976 (char *) "self", NULL
40977 };
40978
40979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
40980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40981 if (SWIG_arg_fail(1)) SWIG_fail;
40982 {
40983 PyThreadState* __tstate = wxPyBeginAllowThreads();
40984 (arg1)->Realize();
40985
40986 wxPyEndAllowThreads(__tstate);
40987 if (PyErr_Occurred()) SWIG_fail;
40988 }
40989 Py_INCREF(Py_None); resultobj = Py_None;
40990 return resultobj;
40991 fail:
40992 return NULL;
40993 }
40994
40995
40996 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40997 PyObject *resultobj;
40998 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40999 wxButton *arg2 = (wxButton *) 0 ;
41000 PyObject * obj0 = 0 ;
41001 PyObject * obj1 = 0 ;
41002 char *kwnames[] = {
41003 (char *) "self",(char *) "button", NULL
41004 };
41005
41006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41008 if (SWIG_arg_fail(1)) SWIG_fail;
41009 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41010 if (SWIG_arg_fail(2)) SWIG_fail;
41011 {
41012 PyThreadState* __tstate = wxPyBeginAllowThreads();
41013 (arg1)->SetAffirmativeButton(arg2);
41014
41015 wxPyEndAllowThreads(__tstate);
41016 if (PyErr_Occurred()) SWIG_fail;
41017 }
41018 Py_INCREF(Py_None); resultobj = Py_None;
41019 return resultobj;
41020 fail:
41021 return NULL;
41022 }
41023
41024
41025 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41026 PyObject *resultobj;
41027 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41028 wxButton *arg2 = (wxButton *) 0 ;
41029 PyObject * obj0 = 0 ;
41030 PyObject * obj1 = 0 ;
41031 char *kwnames[] = {
41032 (char *) "self",(char *) "button", NULL
41033 };
41034
41035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41037 if (SWIG_arg_fail(1)) SWIG_fail;
41038 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41039 if (SWIG_arg_fail(2)) SWIG_fail;
41040 {
41041 PyThreadState* __tstate = wxPyBeginAllowThreads();
41042 (arg1)->SetNegativeButton(arg2);
41043
41044 wxPyEndAllowThreads(__tstate);
41045 if (PyErr_Occurred()) SWIG_fail;
41046 }
41047 Py_INCREF(Py_None); resultobj = Py_None;
41048 return resultobj;
41049 fail:
41050 return NULL;
41051 }
41052
41053
41054 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41055 PyObject *resultobj;
41056 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41057 wxButton *arg2 = (wxButton *) 0 ;
41058 PyObject * obj0 = 0 ;
41059 PyObject * obj1 = 0 ;
41060 char *kwnames[] = {
41061 (char *) "self",(char *) "button", NULL
41062 };
41063
41064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41066 if (SWIG_arg_fail(1)) SWIG_fail;
41067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41068 if (SWIG_arg_fail(2)) SWIG_fail;
41069 {
41070 PyThreadState* __tstate = wxPyBeginAllowThreads();
41071 (arg1)->SetCancelButton(arg2);
41072
41073 wxPyEndAllowThreads(__tstate);
41074 if (PyErr_Occurred()) SWIG_fail;
41075 }
41076 Py_INCREF(Py_None); resultobj = Py_None;
41077 return resultobj;
41078 fail:
41079 return NULL;
41080 }
41081
41082
41083 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41084 PyObject *resultobj;
41085 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41086 wxButton *result;
41087 PyObject * obj0 = 0 ;
41088 char *kwnames[] = {
41089 (char *) "self", NULL
41090 };
41091
41092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41094 if (SWIG_arg_fail(1)) SWIG_fail;
41095 {
41096 PyThreadState* __tstate = wxPyBeginAllowThreads();
41097 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41098
41099 wxPyEndAllowThreads(__tstate);
41100 if (PyErr_Occurred()) SWIG_fail;
41101 }
41102 {
41103 resultobj = wxPyMake_wxObject(result, 0);
41104 }
41105 return resultobj;
41106 fail:
41107 return NULL;
41108 }
41109
41110
41111 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41112 PyObject *resultobj;
41113 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41114 wxButton *result;
41115 PyObject * obj0 = 0 ;
41116 char *kwnames[] = {
41117 (char *) "self", NULL
41118 };
41119
41120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41122 if (SWIG_arg_fail(1)) SWIG_fail;
41123 {
41124 PyThreadState* __tstate = wxPyBeginAllowThreads();
41125 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41126
41127 wxPyEndAllowThreads(__tstate);
41128 if (PyErr_Occurred()) SWIG_fail;
41129 }
41130 {
41131 resultobj = wxPyMake_wxObject(result, 0);
41132 }
41133 return resultobj;
41134 fail:
41135 return NULL;
41136 }
41137
41138
41139 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41140 PyObject *resultobj;
41141 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41142 wxButton *result;
41143 PyObject * obj0 = 0 ;
41144 char *kwnames[] = {
41145 (char *) "self", NULL
41146 };
41147
41148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41150 if (SWIG_arg_fail(1)) SWIG_fail;
41151 {
41152 PyThreadState* __tstate = wxPyBeginAllowThreads();
41153 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41154
41155 wxPyEndAllowThreads(__tstate);
41156 if (PyErr_Occurred()) SWIG_fail;
41157 }
41158 {
41159 resultobj = wxPyMake_wxObject(result, 0);
41160 }
41161 return resultobj;
41162 fail:
41163 return NULL;
41164 }
41165
41166
41167 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41168 PyObject *resultobj;
41169 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41170 wxButton *result;
41171 PyObject * obj0 = 0 ;
41172 char *kwnames[] = {
41173 (char *) "self", NULL
41174 };
41175
41176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41178 if (SWIG_arg_fail(1)) SWIG_fail;
41179 {
41180 PyThreadState* __tstate = wxPyBeginAllowThreads();
41181 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41182
41183 wxPyEndAllowThreads(__tstate);
41184 if (PyErr_Occurred()) SWIG_fail;
41185 }
41186 {
41187 resultobj = wxPyMake_wxObject(result, 0);
41188 }
41189 return resultobj;
41190 fail:
41191 return NULL;
41192 }
41193
41194
41195 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41196 PyObject *resultobj;
41197 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41198 wxButton *result;
41199 PyObject * obj0 = 0 ;
41200 char *kwnames[] = {
41201 (char *) "self", NULL
41202 };
41203
41204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41206 if (SWIG_arg_fail(1)) SWIG_fail;
41207 {
41208 PyThreadState* __tstate = wxPyBeginAllowThreads();
41209 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41210
41211 wxPyEndAllowThreads(__tstate);
41212 if (PyErr_Occurred()) SWIG_fail;
41213 }
41214 {
41215 resultobj = wxPyMake_wxObject(result, 0);
41216 }
41217 return resultobj;
41218 fail:
41219 return NULL;
41220 }
41221
41222
41223 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41224 PyObject *obj;
41225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41226 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41227 Py_INCREF(obj);
41228 return Py_BuildValue((char *)"");
41229 }
41230 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41231 PyObject *resultobj;
41232 int arg1 = (int) 0 ;
41233 int arg2 = (int) 0 ;
41234 wxGBPosition *result;
41235 PyObject * obj0 = 0 ;
41236 PyObject * obj1 = 0 ;
41237 char *kwnames[] = {
41238 (char *) "row",(char *) "col", NULL
41239 };
41240
41241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41242 if (obj0) {
41243 {
41244 arg1 = (int)(SWIG_As_int(obj0));
41245 if (SWIG_arg_fail(1)) SWIG_fail;
41246 }
41247 }
41248 if (obj1) {
41249 {
41250 arg2 = (int)(SWIG_As_int(obj1));
41251 if (SWIG_arg_fail(2)) SWIG_fail;
41252 }
41253 }
41254 {
41255 PyThreadState* __tstate = wxPyBeginAllowThreads();
41256 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41257
41258 wxPyEndAllowThreads(__tstate);
41259 if (PyErr_Occurred()) SWIG_fail;
41260 }
41261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41262 return resultobj;
41263 fail:
41264 return NULL;
41265 }
41266
41267
41268 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41269 PyObject *resultobj;
41270 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41271 int result;
41272 PyObject * obj0 = 0 ;
41273 char *kwnames[] = {
41274 (char *) "self", NULL
41275 };
41276
41277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41279 if (SWIG_arg_fail(1)) SWIG_fail;
41280 {
41281 PyThreadState* __tstate = wxPyBeginAllowThreads();
41282 result = (int)((wxGBPosition const *)arg1)->GetRow();
41283
41284 wxPyEndAllowThreads(__tstate);
41285 if (PyErr_Occurred()) SWIG_fail;
41286 }
41287 {
41288 resultobj = SWIG_From_int((int)(result));
41289 }
41290 return resultobj;
41291 fail:
41292 return NULL;
41293 }
41294
41295
41296 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41297 PyObject *resultobj;
41298 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41299 int result;
41300 PyObject * obj0 = 0 ;
41301 char *kwnames[] = {
41302 (char *) "self", NULL
41303 };
41304
41305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41307 if (SWIG_arg_fail(1)) SWIG_fail;
41308 {
41309 PyThreadState* __tstate = wxPyBeginAllowThreads();
41310 result = (int)((wxGBPosition const *)arg1)->GetCol();
41311
41312 wxPyEndAllowThreads(__tstate);
41313 if (PyErr_Occurred()) SWIG_fail;
41314 }
41315 {
41316 resultobj = SWIG_From_int((int)(result));
41317 }
41318 return resultobj;
41319 fail:
41320 return NULL;
41321 }
41322
41323
41324 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41325 PyObject *resultobj;
41326 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41327 int arg2 ;
41328 PyObject * obj0 = 0 ;
41329 PyObject * obj1 = 0 ;
41330 char *kwnames[] = {
41331 (char *) "self",(char *) "row", NULL
41332 };
41333
41334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41336 if (SWIG_arg_fail(1)) SWIG_fail;
41337 {
41338 arg2 = (int)(SWIG_As_int(obj1));
41339 if (SWIG_arg_fail(2)) SWIG_fail;
41340 }
41341 {
41342 PyThreadState* __tstate = wxPyBeginAllowThreads();
41343 (arg1)->SetRow(arg2);
41344
41345 wxPyEndAllowThreads(__tstate);
41346 if (PyErr_Occurred()) SWIG_fail;
41347 }
41348 Py_INCREF(Py_None); resultobj = Py_None;
41349 return resultobj;
41350 fail:
41351 return NULL;
41352 }
41353
41354
41355 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41356 PyObject *resultobj;
41357 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41358 int arg2 ;
41359 PyObject * obj0 = 0 ;
41360 PyObject * obj1 = 0 ;
41361 char *kwnames[] = {
41362 (char *) "self",(char *) "col", NULL
41363 };
41364
41365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41367 if (SWIG_arg_fail(1)) SWIG_fail;
41368 {
41369 arg2 = (int)(SWIG_As_int(obj1));
41370 if (SWIG_arg_fail(2)) SWIG_fail;
41371 }
41372 {
41373 PyThreadState* __tstate = wxPyBeginAllowThreads();
41374 (arg1)->SetCol(arg2);
41375
41376 wxPyEndAllowThreads(__tstate);
41377 if (PyErr_Occurred()) SWIG_fail;
41378 }
41379 Py_INCREF(Py_None); resultobj = Py_None;
41380 return resultobj;
41381 fail:
41382 return NULL;
41383 }
41384
41385
41386 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41387 PyObject *resultobj;
41388 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41389 wxGBPosition *arg2 = 0 ;
41390 bool result;
41391 wxGBPosition temp2 ;
41392 PyObject * obj0 = 0 ;
41393 PyObject * obj1 = 0 ;
41394 char *kwnames[] = {
41395 (char *) "self",(char *) "other", NULL
41396 };
41397
41398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41400 if (SWIG_arg_fail(1)) SWIG_fail;
41401 {
41402 arg2 = &temp2;
41403 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41404 }
41405 {
41406 PyThreadState* __tstate = wxPyBeginAllowThreads();
41407 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41408
41409 wxPyEndAllowThreads(__tstate);
41410 if (PyErr_Occurred()) SWIG_fail;
41411 }
41412 {
41413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41414 }
41415 return resultobj;
41416 fail:
41417 return NULL;
41418 }
41419
41420
41421 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41422 PyObject *resultobj;
41423 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41424 wxGBPosition *arg2 = 0 ;
41425 bool result;
41426 wxGBPosition temp2 ;
41427 PyObject * obj0 = 0 ;
41428 PyObject * obj1 = 0 ;
41429 char *kwnames[] = {
41430 (char *) "self",(char *) "other", NULL
41431 };
41432
41433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41435 if (SWIG_arg_fail(1)) SWIG_fail;
41436 {
41437 arg2 = &temp2;
41438 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41439 }
41440 {
41441 PyThreadState* __tstate = wxPyBeginAllowThreads();
41442 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41443
41444 wxPyEndAllowThreads(__tstate);
41445 if (PyErr_Occurred()) SWIG_fail;
41446 }
41447 {
41448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41449 }
41450 return resultobj;
41451 fail:
41452 return NULL;
41453 }
41454
41455
41456 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41457 PyObject *resultobj;
41458 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41459 int arg2 = (int) 0 ;
41460 int arg3 = (int) 0 ;
41461 PyObject * obj0 = 0 ;
41462 PyObject * obj1 = 0 ;
41463 PyObject * obj2 = 0 ;
41464 char *kwnames[] = {
41465 (char *) "self",(char *) "row",(char *) "col", NULL
41466 };
41467
41468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41470 if (SWIG_arg_fail(1)) SWIG_fail;
41471 if (obj1) {
41472 {
41473 arg2 = (int)(SWIG_As_int(obj1));
41474 if (SWIG_arg_fail(2)) SWIG_fail;
41475 }
41476 }
41477 if (obj2) {
41478 {
41479 arg3 = (int)(SWIG_As_int(obj2));
41480 if (SWIG_arg_fail(3)) SWIG_fail;
41481 }
41482 }
41483 {
41484 PyThreadState* __tstate = wxPyBeginAllowThreads();
41485 wxGBPosition_Set(arg1,arg2,arg3);
41486
41487 wxPyEndAllowThreads(__tstate);
41488 if (PyErr_Occurred()) SWIG_fail;
41489 }
41490 Py_INCREF(Py_None); resultobj = Py_None;
41491 return resultobj;
41492 fail:
41493 return NULL;
41494 }
41495
41496
41497 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41498 PyObject *resultobj;
41499 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41500 PyObject *result;
41501 PyObject * obj0 = 0 ;
41502 char *kwnames[] = {
41503 (char *) "self", NULL
41504 };
41505
41506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41508 if (SWIG_arg_fail(1)) SWIG_fail;
41509 {
41510 PyThreadState* __tstate = wxPyBeginAllowThreads();
41511 result = (PyObject *)wxGBPosition_Get(arg1);
41512
41513 wxPyEndAllowThreads(__tstate);
41514 if (PyErr_Occurred()) SWIG_fail;
41515 }
41516 resultobj = result;
41517 return resultobj;
41518 fail:
41519 return NULL;
41520 }
41521
41522
41523 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
41524 PyObject *obj;
41525 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41526 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
41527 Py_INCREF(obj);
41528 return Py_BuildValue((char *)"");
41529 }
41530 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41531 PyObject *resultobj;
41532 int arg1 = (int) 1 ;
41533 int arg2 = (int) 1 ;
41534 wxGBSpan *result;
41535 PyObject * obj0 = 0 ;
41536 PyObject * obj1 = 0 ;
41537 char *kwnames[] = {
41538 (char *) "rowspan",(char *) "colspan", NULL
41539 };
41540
41541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
41542 if (obj0) {
41543 {
41544 arg1 = (int)(SWIG_As_int(obj0));
41545 if (SWIG_arg_fail(1)) SWIG_fail;
41546 }
41547 }
41548 if (obj1) {
41549 {
41550 arg2 = (int)(SWIG_As_int(obj1));
41551 if (SWIG_arg_fail(2)) SWIG_fail;
41552 }
41553 }
41554 {
41555 PyThreadState* __tstate = wxPyBeginAllowThreads();
41556 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
41557
41558 wxPyEndAllowThreads(__tstate);
41559 if (PyErr_Occurred()) SWIG_fail;
41560 }
41561 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
41562 return resultobj;
41563 fail:
41564 return NULL;
41565 }
41566
41567
41568 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41569 PyObject *resultobj;
41570 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41571 int result;
41572 PyObject * obj0 = 0 ;
41573 char *kwnames[] = {
41574 (char *) "self", NULL
41575 };
41576
41577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
41578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41579 if (SWIG_arg_fail(1)) SWIG_fail;
41580 {
41581 PyThreadState* __tstate = wxPyBeginAllowThreads();
41582 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
41583
41584 wxPyEndAllowThreads(__tstate);
41585 if (PyErr_Occurred()) SWIG_fail;
41586 }
41587 {
41588 resultobj = SWIG_From_int((int)(result));
41589 }
41590 return resultobj;
41591 fail:
41592 return NULL;
41593 }
41594
41595
41596 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41597 PyObject *resultobj;
41598 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41599 int result;
41600 PyObject * obj0 = 0 ;
41601 char *kwnames[] = {
41602 (char *) "self", NULL
41603 };
41604
41605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
41606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41607 if (SWIG_arg_fail(1)) SWIG_fail;
41608 {
41609 PyThreadState* __tstate = wxPyBeginAllowThreads();
41610 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41611
41612 wxPyEndAllowThreads(__tstate);
41613 if (PyErr_Occurred()) SWIG_fail;
41614 }
41615 {
41616 resultobj = SWIG_From_int((int)(result));
41617 }
41618 return resultobj;
41619 fail:
41620 return NULL;
41621 }
41622
41623
41624 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41625 PyObject *resultobj;
41626 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41627 int arg2 ;
41628 PyObject * obj0 = 0 ;
41629 PyObject * obj1 = 0 ;
41630 char *kwnames[] = {
41631 (char *) "self",(char *) "rowspan", NULL
41632 };
41633
41634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41636 if (SWIG_arg_fail(1)) SWIG_fail;
41637 {
41638 arg2 = (int)(SWIG_As_int(obj1));
41639 if (SWIG_arg_fail(2)) SWIG_fail;
41640 }
41641 {
41642 PyThreadState* __tstate = wxPyBeginAllowThreads();
41643 (arg1)->SetRowspan(arg2);
41644
41645 wxPyEndAllowThreads(__tstate);
41646 if (PyErr_Occurred()) SWIG_fail;
41647 }
41648 Py_INCREF(Py_None); resultobj = Py_None;
41649 return resultobj;
41650 fail:
41651 return NULL;
41652 }
41653
41654
41655 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41656 PyObject *resultobj;
41657 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41658 int arg2 ;
41659 PyObject * obj0 = 0 ;
41660 PyObject * obj1 = 0 ;
41661 char *kwnames[] = {
41662 (char *) "self",(char *) "colspan", NULL
41663 };
41664
41665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41667 if (SWIG_arg_fail(1)) SWIG_fail;
41668 {
41669 arg2 = (int)(SWIG_As_int(obj1));
41670 if (SWIG_arg_fail(2)) SWIG_fail;
41671 }
41672 {
41673 PyThreadState* __tstate = wxPyBeginAllowThreads();
41674 (arg1)->SetColspan(arg2);
41675
41676 wxPyEndAllowThreads(__tstate);
41677 if (PyErr_Occurred()) SWIG_fail;
41678 }
41679 Py_INCREF(Py_None); resultobj = Py_None;
41680 return resultobj;
41681 fail:
41682 return NULL;
41683 }
41684
41685
41686 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41687 PyObject *resultobj;
41688 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41689 wxGBSpan *arg2 = 0 ;
41690 bool result;
41691 wxGBSpan temp2 ;
41692 PyObject * obj0 = 0 ;
41693 PyObject * obj1 = 0 ;
41694 char *kwnames[] = {
41695 (char *) "self",(char *) "other", NULL
41696 };
41697
41698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41700 if (SWIG_arg_fail(1)) SWIG_fail;
41701 {
41702 arg2 = &temp2;
41703 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41704 }
41705 {
41706 PyThreadState* __tstate = wxPyBeginAllowThreads();
41707 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41708
41709 wxPyEndAllowThreads(__tstate);
41710 if (PyErr_Occurred()) SWIG_fail;
41711 }
41712 {
41713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41714 }
41715 return resultobj;
41716 fail:
41717 return NULL;
41718 }
41719
41720
41721 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41722 PyObject *resultobj;
41723 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41724 wxGBSpan *arg2 = 0 ;
41725 bool result;
41726 wxGBSpan temp2 ;
41727 PyObject * obj0 = 0 ;
41728 PyObject * obj1 = 0 ;
41729 char *kwnames[] = {
41730 (char *) "self",(char *) "other", NULL
41731 };
41732
41733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41735 if (SWIG_arg_fail(1)) SWIG_fail;
41736 {
41737 arg2 = &temp2;
41738 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41739 }
41740 {
41741 PyThreadState* __tstate = wxPyBeginAllowThreads();
41742 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41743
41744 wxPyEndAllowThreads(__tstate);
41745 if (PyErr_Occurred()) SWIG_fail;
41746 }
41747 {
41748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41749 }
41750 return resultobj;
41751 fail:
41752 return NULL;
41753 }
41754
41755
41756 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41757 PyObject *resultobj;
41758 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41759 int arg2 = (int) 1 ;
41760 int arg3 = (int) 1 ;
41761 PyObject * obj0 = 0 ;
41762 PyObject * obj1 = 0 ;
41763 PyObject * obj2 = 0 ;
41764 char *kwnames[] = {
41765 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41766 };
41767
41768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41770 if (SWIG_arg_fail(1)) SWIG_fail;
41771 if (obj1) {
41772 {
41773 arg2 = (int)(SWIG_As_int(obj1));
41774 if (SWIG_arg_fail(2)) SWIG_fail;
41775 }
41776 }
41777 if (obj2) {
41778 {
41779 arg3 = (int)(SWIG_As_int(obj2));
41780 if (SWIG_arg_fail(3)) SWIG_fail;
41781 }
41782 }
41783 {
41784 PyThreadState* __tstate = wxPyBeginAllowThreads();
41785 wxGBSpan_Set(arg1,arg2,arg3);
41786
41787 wxPyEndAllowThreads(__tstate);
41788 if (PyErr_Occurred()) SWIG_fail;
41789 }
41790 Py_INCREF(Py_None); resultobj = Py_None;
41791 return resultobj;
41792 fail:
41793 return NULL;
41794 }
41795
41796
41797 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41798 PyObject *resultobj;
41799 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41800 PyObject *result;
41801 PyObject * obj0 = 0 ;
41802 char *kwnames[] = {
41803 (char *) "self", NULL
41804 };
41805
41806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41808 if (SWIG_arg_fail(1)) SWIG_fail;
41809 {
41810 PyThreadState* __tstate = wxPyBeginAllowThreads();
41811 result = (PyObject *)wxGBSpan_Get(arg1);
41812
41813 wxPyEndAllowThreads(__tstate);
41814 if (PyErr_Occurred()) SWIG_fail;
41815 }
41816 resultobj = result;
41817 return resultobj;
41818 fail:
41819 return NULL;
41820 }
41821
41822
41823 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41824 PyObject *obj;
41825 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41826 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41827 Py_INCREF(obj);
41828 return Py_BuildValue((char *)"");
41829 }
41830 static int _wrap_DefaultSpan_set(PyObject *) {
41831 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41832 return 1;
41833 }
41834
41835
41836 static PyObject *_wrap_DefaultSpan_get(void) {
41837 PyObject *pyobj;
41838
41839 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41840 return pyobj;
41841 }
41842
41843
41844 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41845 PyObject *resultobj;
41846 wxGBSizerItem *result;
41847 char *kwnames[] = {
41848 NULL
41849 };
41850
41851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41852 {
41853 PyThreadState* __tstate = wxPyBeginAllowThreads();
41854 result = (wxGBSizerItem *)new wxGBSizerItem();
41855
41856 wxPyEndAllowThreads(__tstate);
41857 if (PyErr_Occurred()) SWIG_fail;
41858 }
41859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41860 return resultobj;
41861 fail:
41862 return NULL;
41863 }
41864
41865
41866 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41867 PyObject *resultobj;
41868 wxWindow *arg1 = (wxWindow *) 0 ;
41869 wxGBPosition *arg2 = 0 ;
41870 wxGBSpan *arg3 = 0 ;
41871 int arg4 ;
41872 int arg5 ;
41873 PyObject *arg6 = (PyObject *) NULL ;
41874 wxGBSizerItem *result;
41875 wxGBPosition temp2 ;
41876 wxGBSpan temp3 ;
41877 PyObject * obj0 = 0 ;
41878 PyObject * obj1 = 0 ;
41879 PyObject * obj2 = 0 ;
41880 PyObject * obj3 = 0 ;
41881 PyObject * obj4 = 0 ;
41882 PyObject * obj5 = 0 ;
41883 char *kwnames[] = {
41884 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41885 };
41886
41887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41889 if (SWIG_arg_fail(1)) SWIG_fail;
41890 {
41891 arg2 = &temp2;
41892 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41893 }
41894 {
41895 arg3 = &temp3;
41896 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41897 }
41898 {
41899 arg4 = (int)(SWIG_As_int(obj3));
41900 if (SWIG_arg_fail(4)) SWIG_fail;
41901 }
41902 {
41903 arg5 = (int)(SWIG_As_int(obj4));
41904 if (SWIG_arg_fail(5)) SWIG_fail;
41905 }
41906 if (obj5) {
41907 arg6 = obj5;
41908 }
41909 {
41910 PyThreadState* __tstate = wxPyBeginAllowThreads();
41911 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41912
41913 wxPyEndAllowThreads(__tstate);
41914 if (PyErr_Occurred()) SWIG_fail;
41915 }
41916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41917 return resultobj;
41918 fail:
41919 return NULL;
41920 }
41921
41922
41923 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41924 PyObject *resultobj;
41925 wxSizer *arg1 = (wxSizer *) 0 ;
41926 wxGBPosition *arg2 = 0 ;
41927 wxGBSpan *arg3 = 0 ;
41928 int arg4 ;
41929 int arg5 ;
41930 PyObject *arg6 = (PyObject *) NULL ;
41931 wxGBSizerItem *result;
41932 wxGBPosition temp2 ;
41933 wxGBSpan temp3 ;
41934 PyObject * obj0 = 0 ;
41935 PyObject * obj1 = 0 ;
41936 PyObject * obj2 = 0 ;
41937 PyObject * obj3 = 0 ;
41938 PyObject * obj4 = 0 ;
41939 PyObject * obj5 = 0 ;
41940 char *kwnames[] = {
41941 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41942 };
41943
41944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41946 if (SWIG_arg_fail(1)) SWIG_fail;
41947 {
41948 arg2 = &temp2;
41949 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41950 }
41951 {
41952 arg3 = &temp3;
41953 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41954 }
41955 {
41956 arg4 = (int)(SWIG_As_int(obj3));
41957 if (SWIG_arg_fail(4)) SWIG_fail;
41958 }
41959 {
41960 arg5 = (int)(SWIG_As_int(obj4));
41961 if (SWIG_arg_fail(5)) SWIG_fail;
41962 }
41963 if (obj5) {
41964 arg6 = obj5;
41965 }
41966 {
41967 PyThreadState* __tstate = wxPyBeginAllowThreads();
41968 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41969
41970 wxPyEndAllowThreads(__tstate);
41971 if (PyErr_Occurred()) SWIG_fail;
41972 }
41973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41974 return resultobj;
41975 fail:
41976 return NULL;
41977 }
41978
41979
41980 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41981 PyObject *resultobj;
41982 int arg1 ;
41983 int arg2 ;
41984 wxGBPosition *arg3 = 0 ;
41985 wxGBSpan *arg4 = 0 ;
41986 int arg5 ;
41987 int arg6 ;
41988 PyObject *arg7 = (PyObject *) NULL ;
41989 wxGBSizerItem *result;
41990 wxGBPosition temp3 ;
41991 wxGBSpan temp4 ;
41992 PyObject * obj0 = 0 ;
41993 PyObject * obj1 = 0 ;
41994 PyObject * obj2 = 0 ;
41995 PyObject * obj3 = 0 ;
41996 PyObject * obj4 = 0 ;
41997 PyObject * obj5 = 0 ;
41998 PyObject * obj6 = 0 ;
41999 char *kwnames[] = {
42000 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42001 };
42002
42003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42004 {
42005 arg1 = (int)(SWIG_As_int(obj0));
42006 if (SWIG_arg_fail(1)) SWIG_fail;
42007 }
42008 {
42009 arg2 = (int)(SWIG_As_int(obj1));
42010 if (SWIG_arg_fail(2)) SWIG_fail;
42011 }
42012 {
42013 arg3 = &temp3;
42014 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42015 }
42016 {
42017 arg4 = &temp4;
42018 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42019 }
42020 {
42021 arg5 = (int)(SWIG_As_int(obj4));
42022 if (SWIG_arg_fail(5)) SWIG_fail;
42023 }
42024 {
42025 arg6 = (int)(SWIG_As_int(obj5));
42026 if (SWIG_arg_fail(6)) SWIG_fail;
42027 }
42028 if (obj6) {
42029 arg7 = obj6;
42030 }
42031 {
42032 PyThreadState* __tstate = wxPyBeginAllowThreads();
42033 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42034
42035 wxPyEndAllowThreads(__tstate);
42036 if (PyErr_Occurred()) SWIG_fail;
42037 }
42038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42039 return resultobj;
42040 fail:
42041 return NULL;
42042 }
42043
42044
42045 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42046 PyObject *resultobj;
42047 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42048 wxGBPosition result;
42049 PyObject * obj0 = 0 ;
42050 char *kwnames[] = {
42051 (char *) "self", NULL
42052 };
42053
42054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42056 if (SWIG_arg_fail(1)) SWIG_fail;
42057 {
42058 PyThreadState* __tstate = wxPyBeginAllowThreads();
42059 result = ((wxGBSizerItem const *)arg1)->GetPos();
42060
42061 wxPyEndAllowThreads(__tstate);
42062 if (PyErr_Occurred()) SWIG_fail;
42063 }
42064 {
42065 wxGBPosition * resultptr;
42066 resultptr = new wxGBPosition((wxGBPosition &)(result));
42067 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42068 }
42069 return resultobj;
42070 fail:
42071 return NULL;
42072 }
42073
42074
42075 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42076 PyObject *resultobj;
42077 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42078 wxGBSpan result;
42079 PyObject * obj0 = 0 ;
42080 char *kwnames[] = {
42081 (char *) "self", NULL
42082 };
42083
42084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42086 if (SWIG_arg_fail(1)) SWIG_fail;
42087 {
42088 PyThreadState* __tstate = wxPyBeginAllowThreads();
42089 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42090
42091 wxPyEndAllowThreads(__tstate);
42092 if (PyErr_Occurred()) SWIG_fail;
42093 }
42094 {
42095 wxGBSpan * resultptr;
42096 resultptr = new wxGBSpan((wxGBSpan &)(result));
42097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42098 }
42099 return resultobj;
42100 fail:
42101 return NULL;
42102 }
42103
42104
42105 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42106 PyObject *resultobj;
42107 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42108 wxGBPosition *arg2 = 0 ;
42109 bool result;
42110 wxGBPosition temp2 ;
42111 PyObject * obj0 = 0 ;
42112 PyObject * obj1 = 0 ;
42113 char *kwnames[] = {
42114 (char *) "self",(char *) "pos", NULL
42115 };
42116
42117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42119 if (SWIG_arg_fail(1)) SWIG_fail;
42120 {
42121 arg2 = &temp2;
42122 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42123 }
42124 {
42125 PyThreadState* __tstate = wxPyBeginAllowThreads();
42126 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42127
42128 wxPyEndAllowThreads(__tstate);
42129 if (PyErr_Occurred()) SWIG_fail;
42130 }
42131 {
42132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42133 }
42134 return resultobj;
42135 fail:
42136 return NULL;
42137 }
42138
42139
42140 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42141 PyObject *resultobj;
42142 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42143 wxGBSpan *arg2 = 0 ;
42144 bool result;
42145 wxGBSpan temp2 ;
42146 PyObject * obj0 = 0 ;
42147 PyObject * obj1 = 0 ;
42148 char *kwnames[] = {
42149 (char *) "self",(char *) "span", NULL
42150 };
42151
42152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42154 if (SWIG_arg_fail(1)) SWIG_fail;
42155 {
42156 arg2 = &temp2;
42157 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42158 }
42159 {
42160 PyThreadState* __tstate = wxPyBeginAllowThreads();
42161 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42162
42163 wxPyEndAllowThreads(__tstate);
42164 if (PyErr_Occurred()) SWIG_fail;
42165 }
42166 {
42167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42168 }
42169 return resultobj;
42170 fail:
42171 return NULL;
42172 }
42173
42174
42175 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42176 PyObject *resultobj;
42177 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42178 wxGBSizerItem *arg2 = 0 ;
42179 bool result;
42180 PyObject * obj0 = 0 ;
42181 PyObject * obj1 = 0 ;
42182 char *kwnames[] = {
42183 (char *) "self",(char *) "other", NULL
42184 };
42185
42186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42188 if (SWIG_arg_fail(1)) SWIG_fail;
42189 {
42190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42191 if (SWIG_arg_fail(2)) SWIG_fail;
42192 if (arg2 == NULL) {
42193 SWIG_null_ref("wxGBSizerItem");
42194 }
42195 if (SWIG_arg_fail(2)) SWIG_fail;
42196 }
42197 {
42198 PyThreadState* __tstate = wxPyBeginAllowThreads();
42199 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42200
42201 wxPyEndAllowThreads(__tstate);
42202 if (PyErr_Occurred()) SWIG_fail;
42203 }
42204 {
42205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42206 }
42207 return resultobj;
42208 fail:
42209 return NULL;
42210 }
42211
42212
42213 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42214 PyObject *resultobj;
42215 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42216 wxGBPosition *arg2 = 0 ;
42217 wxGBSpan *arg3 = 0 ;
42218 bool result;
42219 wxGBPosition temp2 ;
42220 wxGBSpan temp3 ;
42221 PyObject * obj0 = 0 ;
42222 PyObject * obj1 = 0 ;
42223 PyObject * obj2 = 0 ;
42224 char *kwnames[] = {
42225 (char *) "self",(char *) "pos",(char *) "span", NULL
42226 };
42227
42228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42230 if (SWIG_arg_fail(1)) SWIG_fail;
42231 {
42232 arg2 = &temp2;
42233 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42234 }
42235 {
42236 arg3 = &temp3;
42237 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42238 }
42239 {
42240 PyThreadState* __tstate = wxPyBeginAllowThreads();
42241 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42242
42243 wxPyEndAllowThreads(__tstate);
42244 if (PyErr_Occurred()) SWIG_fail;
42245 }
42246 {
42247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42248 }
42249 return resultobj;
42250 fail:
42251 return NULL;
42252 }
42253
42254
42255 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42256 PyObject *resultobj;
42257 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42258 wxGBPosition result;
42259 PyObject * obj0 = 0 ;
42260 char *kwnames[] = {
42261 (char *) "self", NULL
42262 };
42263
42264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42266 if (SWIG_arg_fail(1)) SWIG_fail;
42267 {
42268 PyThreadState* __tstate = wxPyBeginAllowThreads();
42269 result = wxGBSizerItem_GetEndPos(arg1);
42270
42271 wxPyEndAllowThreads(__tstate);
42272 if (PyErr_Occurred()) SWIG_fail;
42273 }
42274 {
42275 wxGBPosition * resultptr;
42276 resultptr = new wxGBPosition((wxGBPosition &)(result));
42277 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42278 }
42279 return resultobj;
42280 fail:
42281 return NULL;
42282 }
42283
42284
42285 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42286 PyObject *resultobj;
42287 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42288 wxGridBagSizer *result;
42289 PyObject * obj0 = 0 ;
42290 char *kwnames[] = {
42291 (char *) "self", NULL
42292 };
42293
42294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42296 if (SWIG_arg_fail(1)) SWIG_fail;
42297 {
42298 PyThreadState* __tstate = wxPyBeginAllowThreads();
42299 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42300
42301 wxPyEndAllowThreads(__tstate);
42302 if (PyErr_Occurred()) SWIG_fail;
42303 }
42304 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42305 return resultobj;
42306 fail:
42307 return NULL;
42308 }
42309
42310
42311 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42312 PyObject *resultobj;
42313 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42314 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42315 PyObject * obj0 = 0 ;
42316 PyObject * obj1 = 0 ;
42317 char *kwnames[] = {
42318 (char *) "self",(char *) "sizer", NULL
42319 };
42320
42321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42323 if (SWIG_arg_fail(1)) SWIG_fail;
42324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42325 if (SWIG_arg_fail(2)) SWIG_fail;
42326 {
42327 PyThreadState* __tstate = wxPyBeginAllowThreads();
42328 (arg1)->SetGBSizer(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 * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42341 PyObject *obj;
42342 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42343 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42344 Py_INCREF(obj);
42345 return Py_BuildValue((char *)"");
42346 }
42347 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42348 PyObject *resultobj;
42349 int arg1 = (int) 0 ;
42350 int arg2 = (int) 0 ;
42351 wxGridBagSizer *result;
42352 PyObject * obj0 = 0 ;
42353 PyObject * obj1 = 0 ;
42354 char *kwnames[] = {
42355 (char *) "vgap",(char *) "hgap", NULL
42356 };
42357
42358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42359 if (obj0) {
42360 {
42361 arg1 = (int)(SWIG_As_int(obj0));
42362 if (SWIG_arg_fail(1)) SWIG_fail;
42363 }
42364 }
42365 if (obj1) {
42366 {
42367 arg2 = (int)(SWIG_As_int(obj1));
42368 if (SWIG_arg_fail(2)) SWIG_fail;
42369 }
42370 }
42371 {
42372 PyThreadState* __tstate = wxPyBeginAllowThreads();
42373 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42374
42375 wxPyEndAllowThreads(__tstate);
42376 if (PyErr_Occurred()) SWIG_fail;
42377 }
42378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42379 return resultobj;
42380 fail:
42381 return NULL;
42382 }
42383
42384
42385 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42386 PyObject *resultobj;
42387 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42388 PyObject *arg2 = (PyObject *) 0 ;
42389 wxGBPosition *arg3 = 0 ;
42390 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42391 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42392 int arg5 = (int) 0 ;
42393 int arg6 = (int) 0 ;
42394 PyObject *arg7 = (PyObject *) NULL ;
42395 wxGBSizerItem *result;
42396 wxGBPosition temp3 ;
42397 wxGBSpan temp4 ;
42398 PyObject * obj0 = 0 ;
42399 PyObject * obj1 = 0 ;
42400 PyObject * obj2 = 0 ;
42401 PyObject * obj3 = 0 ;
42402 PyObject * obj4 = 0 ;
42403 PyObject * obj5 = 0 ;
42404 PyObject * obj6 = 0 ;
42405 char *kwnames[] = {
42406 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42407 };
42408
42409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42411 if (SWIG_arg_fail(1)) SWIG_fail;
42412 arg2 = obj1;
42413 {
42414 arg3 = &temp3;
42415 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42416 }
42417 if (obj3) {
42418 {
42419 arg4 = &temp4;
42420 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42421 }
42422 }
42423 if (obj4) {
42424 {
42425 arg5 = (int)(SWIG_As_int(obj4));
42426 if (SWIG_arg_fail(5)) SWIG_fail;
42427 }
42428 }
42429 if (obj5) {
42430 {
42431 arg6 = (int)(SWIG_As_int(obj5));
42432 if (SWIG_arg_fail(6)) SWIG_fail;
42433 }
42434 }
42435 if (obj6) {
42436 arg7 = obj6;
42437 }
42438 {
42439 PyThreadState* __tstate = wxPyBeginAllowThreads();
42440 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42441
42442 wxPyEndAllowThreads(__tstate);
42443 if (PyErr_Occurred()) SWIG_fail;
42444 }
42445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42446 return resultobj;
42447 fail:
42448 return NULL;
42449 }
42450
42451
42452 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42453 PyObject *resultobj;
42454 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42455 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42456 wxGBSizerItem *result;
42457 PyObject * obj0 = 0 ;
42458 PyObject * obj1 = 0 ;
42459 char *kwnames[] = {
42460 (char *) "self",(char *) "item", NULL
42461 };
42462
42463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42465 if (SWIG_arg_fail(1)) SWIG_fail;
42466 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42467 if (SWIG_arg_fail(2)) SWIG_fail;
42468 {
42469 PyThreadState* __tstate = wxPyBeginAllowThreads();
42470 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42471
42472 wxPyEndAllowThreads(__tstate);
42473 if (PyErr_Occurred()) SWIG_fail;
42474 }
42475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42476 return resultobj;
42477 fail:
42478 return NULL;
42479 }
42480
42481
42482 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42483 PyObject *resultobj;
42484 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42485 int arg2 ;
42486 int arg3 ;
42487 wxSize result;
42488 PyObject * obj0 = 0 ;
42489 PyObject * obj1 = 0 ;
42490 PyObject * obj2 = 0 ;
42491 char *kwnames[] = {
42492 (char *) "self",(char *) "row",(char *) "col", NULL
42493 };
42494
42495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42497 if (SWIG_arg_fail(1)) SWIG_fail;
42498 {
42499 arg2 = (int)(SWIG_As_int(obj1));
42500 if (SWIG_arg_fail(2)) SWIG_fail;
42501 }
42502 {
42503 arg3 = (int)(SWIG_As_int(obj2));
42504 if (SWIG_arg_fail(3)) SWIG_fail;
42505 }
42506 {
42507 PyThreadState* __tstate = wxPyBeginAllowThreads();
42508 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42509
42510 wxPyEndAllowThreads(__tstate);
42511 if (PyErr_Occurred()) SWIG_fail;
42512 }
42513 {
42514 wxSize * resultptr;
42515 resultptr = new wxSize((wxSize &)(result));
42516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42517 }
42518 return resultobj;
42519 fail:
42520 return NULL;
42521 }
42522
42523
42524 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42525 PyObject *resultobj;
42526 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42527 wxSize result;
42528 PyObject * obj0 = 0 ;
42529 char *kwnames[] = {
42530 (char *) "self", NULL
42531 };
42532
42533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
42534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42535 if (SWIG_arg_fail(1)) SWIG_fail;
42536 {
42537 PyThreadState* __tstate = wxPyBeginAllowThreads();
42538 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
42539
42540 wxPyEndAllowThreads(__tstate);
42541 if (PyErr_Occurred()) SWIG_fail;
42542 }
42543 {
42544 wxSize * resultptr;
42545 resultptr = new wxSize((wxSize &)(result));
42546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
42547 }
42548 return resultobj;
42549 fail:
42550 return NULL;
42551 }
42552
42553
42554 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42555 PyObject *resultobj;
42556 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42557 wxSize *arg2 = 0 ;
42558 wxSize temp2 ;
42559 PyObject * obj0 = 0 ;
42560 PyObject * obj1 = 0 ;
42561 char *kwnames[] = {
42562 (char *) "self",(char *) "sz", NULL
42563 };
42564
42565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
42566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42567 if (SWIG_arg_fail(1)) SWIG_fail;
42568 {
42569 arg2 = &temp2;
42570 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
42571 }
42572 {
42573 PyThreadState* __tstate = wxPyBeginAllowThreads();
42574 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
42575
42576 wxPyEndAllowThreads(__tstate);
42577 if (PyErr_Occurred()) SWIG_fail;
42578 }
42579 Py_INCREF(Py_None); resultobj = Py_None;
42580 return resultobj;
42581 fail:
42582 return NULL;
42583 }
42584
42585
42586 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42587 PyObject *resultobj;
42588 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42589 wxWindow *arg2 = (wxWindow *) 0 ;
42590 wxGBPosition result;
42591 PyObject * obj0 = 0 ;
42592 PyObject * obj1 = 0 ;
42593
42594 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42596 if (SWIG_arg_fail(1)) SWIG_fail;
42597 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42598 if (SWIG_arg_fail(2)) SWIG_fail;
42599 {
42600 PyThreadState* __tstate = wxPyBeginAllowThreads();
42601 result = (arg1)->GetItemPosition(arg2);
42602
42603 wxPyEndAllowThreads(__tstate);
42604 if (PyErr_Occurred()) SWIG_fail;
42605 }
42606 {
42607 wxGBPosition * resultptr;
42608 resultptr = new wxGBPosition((wxGBPosition &)(result));
42609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42610 }
42611 return resultobj;
42612 fail:
42613 return NULL;
42614 }
42615
42616
42617 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42618 PyObject *resultobj;
42619 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42620 wxSizer *arg2 = (wxSizer *) 0 ;
42621 wxGBPosition result;
42622 PyObject * obj0 = 0 ;
42623 PyObject * obj1 = 0 ;
42624
42625 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42627 if (SWIG_arg_fail(1)) SWIG_fail;
42628 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42629 if (SWIG_arg_fail(2)) SWIG_fail;
42630 {
42631 PyThreadState* __tstate = wxPyBeginAllowThreads();
42632 result = (arg1)->GetItemPosition(arg2);
42633
42634 wxPyEndAllowThreads(__tstate);
42635 if (PyErr_Occurred()) SWIG_fail;
42636 }
42637 {
42638 wxGBPosition * resultptr;
42639 resultptr = new wxGBPosition((wxGBPosition &)(result));
42640 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42641 }
42642 return resultobj;
42643 fail:
42644 return NULL;
42645 }
42646
42647
42648 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42649 PyObject *resultobj;
42650 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42651 size_t arg2 ;
42652 wxGBPosition result;
42653 PyObject * obj0 = 0 ;
42654 PyObject * obj1 = 0 ;
42655
42656 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42658 if (SWIG_arg_fail(1)) SWIG_fail;
42659 {
42660 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42661 if (SWIG_arg_fail(2)) SWIG_fail;
42662 }
42663 {
42664 PyThreadState* __tstate = wxPyBeginAllowThreads();
42665 result = (arg1)->GetItemPosition(arg2);
42666
42667 wxPyEndAllowThreads(__tstate);
42668 if (PyErr_Occurred()) SWIG_fail;
42669 }
42670 {
42671 wxGBPosition * resultptr;
42672 resultptr = new wxGBPosition((wxGBPosition &)(result));
42673 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42674 }
42675 return resultobj;
42676 fail:
42677 return NULL;
42678 }
42679
42680
42681 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42682 int argc;
42683 PyObject *argv[3];
42684 int ii;
42685
42686 argc = PyObject_Length(args);
42687 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42688 argv[ii] = PyTuple_GetItem(args,ii);
42689 }
42690 if (argc == 2) {
42691 int _v;
42692 {
42693 void *ptr;
42694 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42695 _v = 0;
42696 PyErr_Clear();
42697 } else {
42698 _v = 1;
42699 }
42700 }
42701 if (_v) {
42702 {
42703 void *ptr;
42704 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42705 _v = 0;
42706 PyErr_Clear();
42707 } else {
42708 _v = 1;
42709 }
42710 }
42711 if (_v) {
42712 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42713 }
42714 }
42715 }
42716 if (argc == 2) {
42717 int _v;
42718 {
42719 void *ptr;
42720 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42721 _v = 0;
42722 PyErr_Clear();
42723 } else {
42724 _v = 1;
42725 }
42726 }
42727 if (_v) {
42728 {
42729 void *ptr;
42730 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42731 _v = 0;
42732 PyErr_Clear();
42733 } else {
42734 _v = 1;
42735 }
42736 }
42737 if (_v) {
42738 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42739 }
42740 }
42741 }
42742 if (argc == 2) {
42743 int _v;
42744 {
42745 void *ptr;
42746 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42747 _v = 0;
42748 PyErr_Clear();
42749 } else {
42750 _v = 1;
42751 }
42752 }
42753 if (_v) {
42754 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42755 if (_v) {
42756 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42757 }
42758 }
42759 }
42760
42761 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42762 return NULL;
42763 }
42764
42765
42766 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42767 PyObject *resultobj;
42768 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42769 wxWindow *arg2 = (wxWindow *) 0 ;
42770 wxGBPosition *arg3 = 0 ;
42771 bool result;
42772 wxGBPosition temp3 ;
42773 PyObject * obj0 = 0 ;
42774 PyObject * obj1 = 0 ;
42775 PyObject * obj2 = 0 ;
42776
42777 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42779 if (SWIG_arg_fail(1)) SWIG_fail;
42780 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42781 if (SWIG_arg_fail(2)) SWIG_fail;
42782 {
42783 arg3 = &temp3;
42784 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42785 }
42786 {
42787 PyThreadState* __tstate = wxPyBeginAllowThreads();
42788 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42789
42790 wxPyEndAllowThreads(__tstate);
42791 if (PyErr_Occurred()) SWIG_fail;
42792 }
42793 {
42794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42795 }
42796 return resultobj;
42797 fail:
42798 return NULL;
42799 }
42800
42801
42802 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42803 PyObject *resultobj;
42804 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42805 wxSizer *arg2 = (wxSizer *) 0 ;
42806 wxGBPosition *arg3 = 0 ;
42807 bool result;
42808 wxGBPosition temp3 ;
42809 PyObject * obj0 = 0 ;
42810 PyObject * obj1 = 0 ;
42811 PyObject * obj2 = 0 ;
42812
42813 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42815 if (SWIG_arg_fail(1)) SWIG_fail;
42816 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42817 if (SWIG_arg_fail(2)) SWIG_fail;
42818 {
42819 arg3 = &temp3;
42820 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42821 }
42822 {
42823 PyThreadState* __tstate = wxPyBeginAllowThreads();
42824 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42825
42826 wxPyEndAllowThreads(__tstate);
42827 if (PyErr_Occurred()) SWIG_fail;
42828 }
42829 {
42830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42831 }
42832 return resultobj;
42833 fail:
42834 return NULL;
42835 }
42836
42837
42838 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42839 PyObject *resultobj;
42840 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42841 size_t arg2 ;
42842 wxGBPosition *arg3 = 0 ;
42843 bool result;
42844 wxGBPosition temp3 ;
42845 PyObject * obj0 = 0 ;
42846 PyObject * obj1 = 0 ;
42847 PyObject * obj2 = 0 ;
42848
42849 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42851 if (SWIG_arg_fail(1)) SWIG_fail;
42852 {
42853 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42854 if (SWIG_arg_fail(2)) SWIG_fail;
42855 }
42856 {
42857 arg3 = &temp3;
42858 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42859 }
42860 {
42861 PyThreadState* __tstate = wxPyBeginAllowThreads();
42862 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42863
42864 wxPyEndAllowThreads(__tstate);
42865 if (PyErr_Occurred()) SWIG_fail;
42866 }
42867 {
42868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42869 }
42870 return resultobj;
42871 fail:
42872 return NULL;
42873 }
42874
42875
42876 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42877 int argc;
42878 PyObject *argv[4];
42879 int ii;
42880
42881 argc = PyObject_Length(args);
42882 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42883 argv[ii] = PyTuple_GetItem(args,ii);
42884 }
42885 if (argc == 3) {
42886 int _v;
42887 {
42888 void *ptr;
42889 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42890 _v = 0;
42891 PyErr_Clear();
42892 } else {
42893 _v = 1;
42894 }
42895 }
42896 if (_v) {
42897 {
42898 void *ptr;
42899 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42900 _v = 0;
42901 PyErr_Clear();
42902 } else {
42903 _v = 1;
42904 }
42905 }
42906 if (_v) {
42907 {
42908 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42909 }
42910 if (_v) {
42911 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42912 }
42913 }
42914 }
42915 }
42916 if (argc == 3) {
42917 int _v;
42918 {
42919 void *ptr;
42920 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42921 _v = 0;
42922 PyErr_Clear();
42923 } else {
42924 _v = 1;
42925 }
42926 }
42927 if (_v) {
42928 {
42929 void *ptr;
42930 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42931 _v = 0;
42932 PyErr_Clear();
42933 } else {
42934 _v = 1;
42935 }
42936 }
42937 if (_v) {
42938 {
42939 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42940 }
42941 if (_v) {
42942 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42943 }
42944 }
42945 }
42946 }
42947 if (argc == 3) {
42948 int _v;
42949 {
42950 void *ptr;
42951 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42952 _v = 0;
42953 PyErr_Clear();
42954 } else {
42955 _v = 1;
42956 }
42957 }
42958 if (_v) {
42959 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42960 if (_v) {
42961 {
42962 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42963 }
42964 if (_v) {
42965 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42966 }
42967 }
42968 }
42969 }
42970
42971 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42972 return NULL;
42973 }
42974
42975
42976 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42977 PyObject *resultobj;
42978 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42979 wxWindow *arg2 = (wxWindow *) 0 ;
42980 wxGBSpan result;
42981 PyObject * obj0 = 0 ;
42982 PyObject * obj1 = 0 ;
42983
42984 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42986 if (SWIG_arg_fail(1)) SWIG_fail;
42987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42988 if (SWIG_arg_fail(2)) SWIG_fail;
42989 {
42990 PyThreadState* __tstate = wxPyBeginAllowThreads();
42991 result = (arg1)->GetItemSpan(arg2);
42992
42993 wxPyEndAllowThreads(__tstate);
42994 if (PyErr_Occurred()) SWIG_fail;
42995 }
42996 {
42997 wxGBSpan * resultptr;
42998 resultptr = new wxGBSpan((wxGBSpan &)(result));
42999 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43000 }
43001 return resultobj;
43002 fail:
43003 return NULL;
43004 }
43005
43006
43007 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43008 PyObject *resultobj;
43009 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43010 wxSizer *arg2 = (wxSizer *) 0 ;
43011 wxGBSpan result;
43012 PyObject * obj0 = 0 ;
43013 PyObject * obj1 = 0 ;
43014
43015 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43017 if (SWIG_arg_fail(1)) SWIG_fail;
43018 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43019 if (SWIG_arg_fail(2)) SWIG_fail;
43020 {
43021 PyThreadState* __tstate = wxPyBeginAllowThreads();
43022 result = (arg1)->GetItemSpan(arg2);
43023
43024 wxPyEndAllowThreads(__tstate);
43025 if (PyErr_Occurred()) SWIG_fail;
43026 }
43027 {
43028 wxGBSpan * resultptr;
43029 resultptr = new wxGBSpan((wxGBSpan &)(result));
43030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43031 }
43032 return resultobj;
43033 fail:
43034 return NULL;
43035 }
43036
43037
43038 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43039 PyObject *resultobj;
43040 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43041 size_t arg2 ;
43042 wxGBSpan result;
43043 PyObject * obj0 = 0 ;
43044 PyObject * obj1 = 0 ;
43045
43046 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43048 if (SWIG_arg_fail(1)) SWIG_fail;
43049 {
43050 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43051 if (SWIG_arg_fail(2)) SWIG_fail;
43052 }
43053 {
43054 PyThreadState* __tstate = wxPyBeginAllowThreads();
43055 result = (arg1)->GetItemSpan(arg2);
43056
43057 wxPyEndAllowThreads(__tstate);
43058 if (PyErr_Occurred()) SWIG_fail;
43059 }
43060 {
43061 wxGBSpan * resultptr;
43062 resultptr = new wxGBSpan((wxGBSpan &)(result));
43063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43064 }
43065 return resultobj;
43066 fail:
43067 return NULL;
43068 }
43069
43070
43071 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43072 int argc;
43073 PyObject *argv[3];
43074 int ii;
43075
43076 argc = PyObject_Length(args);
43077 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43078 argv[ii] = PyTuple_GetItem(args,ii);
43079 }
43080 if (argc == 2) {
43081 int _v;
43082 {
43083 void *ptr;
43084 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43085 _v = 0;
43086 PyErr_Clear();
43087 } else {
43088 _v = 1;
43089 }
43090 }
43091 if (_v) {
43092 {
43093 void *ptr;
43094 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43095 _v = 0;
43096 PyErr_Clear();
43097 } else {
43098 _v = 1;
43099 }
43100 }
43101 if (_v) {
43102 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43103 }
43104 }
43105 }
43106 if (argc == 2) {
43107 int _v;
43108 {
43109 void *ptr;
43110 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43111 _v = 0;
43112 PyErr_Clear();
43113 } else {
43114 _v = 1;
43115 }
43116 }
43117 if (_v) {
43118 {
43119 void *ptr;
43120 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43121 _v = 0;
43122 PyErr_Clear();
43123 } else {
43124 _v = 1;
43125 }
43126 }
43127 if (_v) {
43128 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43129 }
43130 }
43131 }
43132 if (argc == 2) {
43133 int _v;
43134 {
43135 void *ptr;
43136 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43137 _v = 0;
43138 PyErr_Clear();
43139 } else {
43140 _v = 1;
43141 }
43142 }
43143 if (_v) {
43144 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43145 if (_v) {
43146 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43147 }
43148 }
43149 }
43150
43151 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43152 return NULL;
43153 }
43154
43155
43156 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43157 PyObject *resultobj;
43158 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43159 wxWindow *arg2 = (wxWindow *) 0 ;
43160 wxGBSpan *arg3 = 0 ;
43161 bool result;
43162 wxGBSpan temp3 ;
43163 PyObject * obj0 = 0 ;
43164 PyObject * obj1 = 0 ;
43165 PyObject * obj2 = 0 ;
43166
43167 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43169 if (SWIG_arg_fail(1)) SWIG_fail;
43170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43171 if (SWIG_arg_fail(2)) SWIG_fail;
43172 {
43173 arg3 = &temp3;
43174 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43175 }
43176 {
43177 PyThreadState* __tstate = wxPyBeginAllowThreads();
43178 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43179
43180 wxPyEndAllowThreads(__tstate);
43181 if (PyErr_Occurred()) SWIG_fail;
43182 }
43183 {
43184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43185 }
43186 return resultobj;
43187 fail:
43188 return NULL;
43189 }
43190
43191
43192 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43193 PyObject *resultobj;
43194 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43195 wxSizer *arg2 = (wxSizer *) 0 ;
43196 wxGBSpan *arg3 = 0 ;
43197 bool result;
43198 wxGBSpan temp3 ;
43199 PyObject * obj0 = 0 ;
43200 PyObject * obj1 = 0 ;
43201 PyObject * obj2 = 0 ;
43202
43203 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43205 if (SWIG_arg_fail(1)) SWIG_fail;
43206 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43207 if (SWIG_arg_fail(2)) SWIG_fail;
43208 {
43209 arg3 = &temp3;
43210 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43211 }
43212 {
43213 PyThreadState* __tstate = wxPyBeginAllowThreads();
43214 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43215
43216 wxPyEndAllowThreads(__tstate);
43217 if (PyErr_Occurred()) SWIG_fail;
43218 }
43219 {
43220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43221 }
43222 return resultobj;
43223 fail:
43224 return NULL;
43225 }
43226
43227
43228 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43229 PyObject *resultobj;
43230 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43231 size_t arg2 ;
43232 wxGBSpan *arg3 = 0 ;
43233 bool result;
43234 wxGBSpan temp3 ;
43235 PyObject * obj0 = 0 ;
43236 PyObject * obj1 = 0 ;
43237 PyObject * obj2 = 0 ;
43238
43239 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43241 if (SWIG_arg_fail(1)) SWIG_fail;
43242 {
43243 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43244 if (SWIG_arg_fail(2)) SWIG_fail;
43245 }
43246 {
43247 arg3 = &temp3;
43248 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43249 }
43250 {
43251 PyThreadState* __tstate = wxPyBeginAllowThreads();
43252 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43253
43254 wxPyEndAllowThreads(__tstate);
43255 if (PyErr_Occurred()) SWIG_fail;
43256 }
43257 {
43258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43259 }
43260 return resultobj;
43261 fail:
43262 return NULL;
43263 }
43264
43265
43266 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43267 int argc;
43268 PyObject *argv[4];
43269 int ii;
43270
43271 argc = PyObject_Length(args);
43272 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43273 argv[ii] = PyTuple_GetItem(args,ii);
43274 }
43275 if (argc == 3) {
43276 int _v;
43277 {
43278 void *ptr;
43279 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43280 _v = 0;
43281 PyErr_Clear();
43282 } else {
43283 _v = 1;
43284 }
43285 }
43286 if (_v) {
43287 {
43288 void *ptr;
43289 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43290 _v = 0;
43291 PyErr_Clear();
43292 } else {
43293 _v = 1;
43294 }
43295 }
43296 if (_v) {
43297 {
43298 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43299 }
43300 if (_v) {
43301 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43302 }
43303 }
43304 }
43305 }
43306 if (argc == 3) {
43307 int _v;
43308 {
43309 void *ptr;
43310 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43311 _v = 0;
43312 PyErr_Clear();
43313 } else {
43314 _v = 1;
43315 }
43316 }
43317 if (_v) {
43318 {
43319 void *ptr;
43320 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43321 _v = 0;
43322 PyErr_Clear();
43323 } else {
43324 _v = 1;
43325 }
43326 }
43327 if (_v) {
43328 {
43329 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43330 }
43331 if (_v) {
43332 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43333 }
43334 }
43335 }
43336 }
43337 if (argc == 3) {
43338 int _v;
43339 {
43340 void *ptr;
43341 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43342 _v = 0;
43343 PyErr_Clear();
43344 } else {
43345 _v = 1;
43346 }
43347 }
43348 if (_v) {
43349 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43350 if (_v) {
43351 {
43352 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43353 }
43354 if (_v) {
43355 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43356 }
43357 }
43358 }
43359 }
43360
43361 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43362 return NULL;
43363 }
43364
43365
43366 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43367 PyObject *resultobj;
43368 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43369 wxWindow *arg2 = (wxWindow *) 0 ;
43370 wxGBSizerItem *result;
43371 PyObject * obj0 = 0 ;
43372 PyObject * obj1 = 0 ;
43373
43374 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43376 if (SWIG_arg_fail(1)) SWIG_fail;
43377 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43378 if (SWIG_arg_fail(2)) SWIG_fail;
43379 {
43380 PyThreadState* __tstate = wxPyBeginAllowThreads();
43381 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43382
43383 wxPyEndAllowThreads(__tstate);
43384 if (PyErr_Occurred()) SWIG_fail;
43385 }
43386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43387 return resultobj;
43388 fail:
43389 return NULL;
43390 }
43391
43392
43393 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43394 PyObject *resultobj;
43395 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43396 wxSizer *arg2 = (wxSizer *) 0 ;
43397 wxGBSizerItem *result;
43398 PyObject * obj0 = 0 ;
43399 PyObject * obj1 = 0 ;
43400
43401 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43403 if (SWIG_arg_fail(1)) SWIG_fail;
43404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43405 if (SWIG_arg_fail(2)) SWIG_fail;
43406 {
43407 PyThreadState* __tstate = wxPyBeginAllowThreads();
43408 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43409
43410 wxPyEndAllowThreads(__tstate);
43411 if (PyErr_Occurred()) SWIG_fail;
43412 }
43413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43414 return resultobj;
43415 fail:
43416 return NULL;
43417 }
43418
43419
43420 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43421 int argc;
43422 PyObject *argv[3];
43423 int ii;
43424
43425 argc = PyObject_Length(args);
43426 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43427 argv[ii] = PyTuple_GetItem(args,ii);
43428 }
43429 if (argc == 2) {
43430 int _v;
43431 {
43432 void *ptr;
43433 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43434 _v = 0;
43435 PyErr_Clear();
43436 } else {
43437 _v = 1;
43438 }
43439 }
43440 if (_v) {
43441 {
43442 void *ptr;
43443 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43444 _v = 0;
43445 PyErr_Clear();
43446 } else {
43447 _v = 1;
43448 }
43449 }
43450 if (_v) {
43451 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43452 }
43453 }
43454 }
43455 if (argc == 2) {
43456 int _v;
43457 {
43458 void *ptr;
43459 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43460 _v = 0;
43461 PyErr_Clear();
43462 } else {
43463 _v = 1;
43464 }
43465 }
43466 if (_v) {
43467 {
43468 void *ptr;
43469 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43470 _v = 0;
43471 PyErr_Clear();
43472 } else {
43473 _v = 1;
43474 }
43475 }
43476 if (_v) {
43477 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43478 }
43479 }
43480 }
43481
43482 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43483 return NULL;
43484 }
43485
43486
43487 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43488 PyObject *resultobj;
43489 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43490 wxGBPosition *arg2 = 0 ;
43491 wxGBSizerItem *result;
43492 wxGBPosition temp2 ;
43493 PyObject * obj0 = 0 ;
43494 PyObject * obj1 = 0 ;
43495 char *kwnames[] = {
43496 (char *) "self",(char *) "pos", NULL
43497 };
43498
43499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43501 if (SWIG_arg_fail(1)) SWIG_fail;
43502 {
43503 arg2 = &temp2;
43504 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43505 }
43506 {
43507 PyThreadState* __tstate = wxPyBeginAllowThreads();
43508 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43509
43510 wxPyEndAllowThreads(__tstate);
43511 if (PyErr_Occurred()) SWIG_fail;
43512 }
43513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43514 return resultobj;
43515 fail:
43516 return NULL;
43517 }
43518
43519
43520 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
43521 PyObject *resultobj;
43522 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43523 wxPoint *arg2 = 0 ;
43524 wxGBSizerItem *result;
43525 wxPoint temp2 ;
43526 PyObject * obj0 = 0 ;
43527 PyObject * obj1 = 0 ;
43528 char *kwnames[] = {
43529 (char *) "self",(char *) "pt", NULL
43530 };
43531
43532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
43533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43534 if (SWIG_arg_fail(1)) SWIG_fail;
43535 {
43536 arg2 = &temp2;
43537 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
43538 }
43539 {
43540 PyThreadState* __tstate = wxPyBeginAllowThreads();
43541 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
43542
43543 wxPyEndAllowThreads(__tstate);
43544 if (PyErr_Occurred()) SWIG_fail;
43545 }
43546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43547 return resultobj;
43548 fail:
43549 return NULL;
43550 }
43551
43552
43553 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
43554 PyObject *resultobj;
43555 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43556 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43557 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
43558 bool result;
43559 PyObject * obj0 = 0 ;
43560 PyObject * obj1 = 0 ;
43561 PyObject * obj2 = 0 ;
43562 char *kwnames[] = {
43563 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
43564 };
43565
43566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
43567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43568 if (SWIG_arg_fail(1)) SWIG_fail;
43569 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43570 if (SWIG_arg_fail(2)) SWIG_fail;
43571 if (obj2) {
43572 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43573 if (SWIG_arg_fail(3)) SWIG_fail;
43574 }
43575 {
43576 PyThreadState* __tstate = wxPyBeginAllowThreads();
43577 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
43578
43579 wxPyEndAllowThreads(__tstate);
43580 if (PyErr_Occurred()) SWIG_fail;
43581 }
43582 {
43583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43584 }
43585 return resultobj;
43586 fail:
43587 return NULL;
43588 }
43589
43590
43591 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
43592 PyObject *resultobj;
43593 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43594 wxGBPosition *arg2 = 0 ;
43595 wxGBSpan *arg3 = 0 ;
43596 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
43597 bool result;
43598 wxGBPosition temp2 ;
43599 wxGBSpan temp3 ;
43600 PyObject * obj0 = 0 ;
43601 PyObject * obj1 = 0 ;
43602 PyObject * obj2 = 0 ;
43603 PyObject * obj3 = 0 ;
43604 char *kwnames[] = {
43605 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
43606 };
43607
43608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43610 if (SWIG_arg_fail(1)) SWIG_fail;
43611 {
43612 arg2 = &temp2;
43613 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43614 }
43615 {
43616 arg3 = &temp3;
43617 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43618 }
43619 if (obj3) {
43620 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43621 if (SWIG_arg_fail(4)) SWIG_fail;
43622 }
43623 {
43624 PyThreadState* __tstate = wxPyBeginAllowThreads();
43625 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43626
43627 wxPyEndAllowThreads(__tstate);
43628 if (PyErr_Occurred()) SWIG_fail;
43629 }
43630 {
43631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43632 }
43633 return resultobj;
43634 fail:
43635 return NULL;
43636 }
43637
43638
43639 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43640 PyObject *obj;
43641 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43642 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43643 Py_INCREF(obj);
43644 return Py_BuildValue((char *)"");
43645 }
43646 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43647 PyObject *resultobj;
43648 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43649 wxRelationship arg2 ;
43650 wxWindow *arg3 = (wxWindow *) 0 ;
43651 wxEdge arg4 ;
43652 int arg5 = (int) 0 ;
43653 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43654 PyObject * obj0 = 0 ;
43655 PyObject * obj1 = 0 ;
43656 PyObject * obj2 = 0 ;
43657 PyObject * obj3 = 0 ;
43658 PyObject * obj4 = 0 ;
43659 PyObject * obj5 = 0 ;
43660 char *kwnames[] = {
43661 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43662 };
43663
43664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43666 if (SWIG_arg_fail(1)) SWIG_fail;
43667 {
43668 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43669 if (SWIG_arg_fail(2)) SWIG_fail;
43670 }
43671 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43672 if (SWIG_arg_fail(3)) SWIG_fail;
43673 {
43674 arg4 = (wxEdge)(SWIG_As_int(obj3));
43675 if (SWIG_arg_fail(4)) SWIG_fail;
43676 }
43677 if (obj4) {
43678 {
43679 arg5 = (int)(SWIG_As_int(obj4));
43680 if (SWIG_arg_fail(5)) SWIG_fail;
43681 }
43682 }
43683 if (obj5) {
43684 {
43685 arg6 = (int)(SWIG_As_int(obj5));
43686 if (SWIG_arg_fail(6)) SWIG_fail;
43687 }
43688 }
43689 {
43690 PyThreadState* __tstate = wxPyBeginAllowThreads();
43691 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43692
43693 wxPyEndAllowThreads(__tstate);
43694 if (PyErr_Occurred()) SWIG_fail;
43695 }
43696 Py_INCREF(Py_None); resultobj = Py_None;
43697 return resultobj;
43698 fail:
43699 return NULL;
43700 }
43701
43702
43703 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43704 PyObject *resultobj;
43705 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43706 wxWindow *arg2 = (wxWindow *) 0 ;
43707 int arg3 = (int) 0 ;
43708 PyObject * obj0 = 0 ;
43709 PyObject * obj1 = 0 ;
43710 PyObject * obj2 = 0 ;
43711 char *kwnames[] = {
43712 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43713 };
43714
43715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43717 if (SWIG_arg_fail(1)) SWIG_fail;
43718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43719 if (SWIG_arg_fail(2)) SWIG_fail;
43720 if (obj2) {
43721 {
43722 arg3 = (int)(SWIG_As_int(obj2));
43723 if (SWIG_arg_fail(3)) SWIG_fail;
43724 }
43725 }
43726 {
43727 PyThreadState* __tstate = wxPyBeginAllowThreads();
43728 (arg1)->LeftOf(arg2,arg3);
43729
43730 wxPyEndAllowThreads(__tstate);
43731 if (PyErr_Occurred()) SWIG_fail;
43732 }
43733 Py_INCREF(Py_None); resultobj = Py_None;
43734 return resultobj;
43735 fail:
43736 return NULL;
43737 }
43738
43739
43740 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43741 PyObject *resultobj;
43742 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43743 wxWindow *arg2 = (wxWindow *) 0 ;
43744 int arg3 = (int) 0 ;
43745 PyObject * obj0 = 0 ;
43746 PyObject * obj1 = 0 ;
43747 PyObject * obj2 = 0 ;
43748 char *kwnames[] = {
43749 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43750 };
43751
43752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43754 if (SWIG_arg_fail(1)) SWIG_fail;
43755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43756 if (SWIG_arg_fail(2)) SWIG_fail;
43757 if (obj2) {
43758 {
43759 arg3 = (int)(SWIG_As_int(obj2));
43760 if (SWIG_arg_fail(3)) SWIG_fail;
43761 }
43762 }
43763 {
43764 PyThreadState* __tstate = wxPyBeginAllowThreads();
43765 (arg1)->RightOf(arg2,arg3);
43766
43767 wxPyEndAllowThreads(__tstate);
43768 if (PyErr_Occurred()) SWIG_fail;
43769 }
43770 Py_INCREF(Py_None); resultobj = Py_None;
43771 return resultobj;
43772 fail:
43773 return NULL;
43774 }
43775
43776
43777 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43778 PyObject *resultobj;
43779 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43780 wxWindow *arg2 = (wxWindow *) 0 ;
43781 int arg3 = (int) 0 ;
43782 PyObject * obj0 = 0 ;
43783 PyObject * obj1 = 0 ;
43784 PyObject * obj2 = 0 ;
43785 char *kwnames[] = {
43786 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43787 };
43788
43789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43791 if (SWIG_arg_fail(1)) SWIG_fail;
43792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43793 if (SWIG_arg_fail(2)) SWIG_fail;
43794 if (obj2) {
43795 {
43796 arg3 = (int)(SWIG_As_int(obj2));
43797 if (SWIG_arg_fail(3)) SWIG_fail;
43798 }
43799 }
43800 {
43801 PyThreadState* __tstate = wxPyBeginAllowThreads();
43802 (arg1)->Above(arg2,arg3);
43803
43804 wxPyEndAllowThreads(__tstate);
43805 if (PyErr_Occurred()) SWIG_fail;
43806 }
43807 Py_INCREF(Py_None); resultobj = Py_None;
43808 return resultobj;
43809 fail:
43810 return NULL;
43811 }
43812
43813
43814 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43815 PyObject *resultobj;
43816 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43817 wxWindow *arg2 = (wxWindow *) 0 ;
43818 int arg3 = (int) 0 ;
43819 PyObject * obj0 = 0 ;
43820 PyObject * obj1 = 0 ;
43821 PyObject * obj2 = 0 ;
43822 char *kwnames[] = {
43823 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43824 };
43825
43826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43828 if (SWIG_arg_fail(1)) SWIG_fail;
43829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43830 if (SWIG_arg_fail(2)) SWIG_fail;
43831 if (obj2) {
43832 {
43833 arg3 = (int)(SWIG_As_int(obj2));
43834 if (SWIG_arg_fail(3)) SWIG_fail;
43835 }
43836 }
43837 {
43838 PyThreadState* __tstate = wxPyBeginAllowThreads();
43839 (arg1)->Below(arg2,arg3);
43840
43841 wxPyEndAllowThreads(__tstate);
43842 if (PyErr_Occurred()) SWIG_fail;
43843 }
43844 Py_INCREF(Py_None); resultobj = Py_None;
43845 return resultobj;
43846 fail:
43847 return NULL;
43848 }
43849
43850
43851 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43852 PyObject *resultobj;
43853 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43854 wxWindow *arg2 = (wxWindow *) 0 ;
43855 wxEdge arg3 ;
43856 int arg4 = (int) 0 ;
43857 PyObject * obj0 = 0 ;
43858 PyObject * obj1 = 0 ;
43859 PyObject * obj2 = 0 ;
43860 PyObject * obj3 = 0 ;
43861 char *kwnames[] = {
43862 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43863 };
43864
43865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43867 if (SWIG_arg_fail(1)) SWIG_fail;
43868 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43869 if (SWIG_arg_fail(2)) SWIG_fail;
43870 {
43871 arg3 = (wxEdge)(SWIG_As_int(obj2));
43872 if (SWIG_arg_fail(3)) SWIG_fail;
43873 }
43874 if (obj3) {
43875 {
43876 arg4 = (int)(SWIG_As_int(obj3));
43877 if (SWIG_arg_fail(4)) SWIG_fail;
43878 }
43879 }
43880 {
43881 PyThreadState* __tstate = wxPyBeginAllowThreads();
43882 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43883
43884 wxPyEndAllowThreads(__tstate);
43885 if (PyErr_Occurred()) SWIG_fail;
43886 }
43887 Py_INCREF(Py_None); resultobj = Py_None;
43888 return resultobj;
43889 fail:
43890 return NULL;
43891 }
43892
43893
43894 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43895 PyObject *resultobj;
43896 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43897 wxWindow *arg2 = (wxWindow *) 0 ;
43898 wxEdge arg3 ;
43899 int arg4 ;
43900 PyObject * obj0 = 0 ;
43901 PyObject * obj1 = 0 ;
43902 PyObject * obj2 = 0 ;
43903 PyObject * obj3 = 0 ;
43904 char *kwnames[] = {
43905 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43906 };
43907
43908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43910 if (SWIG_arg_fail(1)) SWIG_fail;
43911 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43912 if (SWIG_arg_fail(2)) SWIG_fail;
43913 {
43914 arg3 = (wxEdge)(SWIG_As_int(obj2));
43915 if (SWIG_arg_fail(3)) SWIG_fail;
43916 }
43917 {
43918 arg4 = (int)(SWIG_As_int(obj3));
43919 if (SWIG_arg_fail(4)) SWIG_fail;
43920 }
43921 {
43922 PyThreadState* __tstate = wxPyBeginAllowThreads();
43923 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43924
43925 wxPyEndAllowThreads(__tstate);
43926 if (PyErr_Occurred()) SWIG_fail;
43927 }
43928 Py_INCREF(Py_None); resultobj = Py_None;
43929 return resultobj;
43930 fail:
43931 return NULL;
43932 }
43933
43934
43935 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43936 PyObject *resultobj;
43937 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43938 int arg2 ;
43939 PyObject * obj0 = 0 ;
43940 PyObject * obj1 = 0 ;
43941 char *kwnames[] = {
43942 (char *) "self",(char *) "val", NULL
43943 };
43944
43945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43947 if (SWIG_arg_fail(1)) SWIG_fail;
43948 {
43949 arg2 = (int)(SWIG_As_int(obj1));
43950 if (SWIG_arg_fail(2)) SWIG_fail;
43951 }
43952 {
43953 PyThreadState* __tstate = wxPyBeginAllowThreads();
43954 (arg1)->Absolute(arg2);
43955
43956 wxPyEndAllowThreads(__tstate);
43957 if (PyErr_Occurred()) SWIG_fail;
43958 }
43959 Py_INCREF(Py_None); resultobj = Py_None;
43960 return resultobj;
43961 fail:
43962 return NULL;
43963 }
43964
43965
43966 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43967 PyObject *resultobj;
43968 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43969 PyObject * obj0 = 0 ;
43970 char *kwnames[] = {
43971 (char *) "self", NULL
43972 };
43973
43974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43976 if (SWIG_arg_fail(1)) SWIG_fail;
43977 {
43978 PyThreadState* __tstate = wxPyBeginAllowThreads();
43979 (arg1)->Unconstrained();
43980
43981 wxPyEndAllowThreads(__tstate);
43982 if (PyErr_Occurred()) SWIG_fail;
43983 }
43984 Py_INCREF(Py_None); resultobj = Py_None;
43985 return resultobj;
43986 fail:
43987 return NULL;
43988 }
43989
43990
43991 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43992 PyObject *resultobj;
43993 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43994 PyObject * obj0 = 0 ;
43995 char *kwnames[] = {
43996 (char *) "self", NULL
43997 };
43998
43999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44001 if (SWIG_arg_fail(1)) SWIG_fail;
44002 {
44003 PyThreadState* __tstate = wxPyBeginAllowThreads();
44004 (arg1)->AsIs();
44005
44006 wxPyEndAllowThreads(__tstate);
44007 if (PyErr_Occurred()) SWIG_fail;
44008 }
44009 Py_INCREF(Py_None); resultobj = Py_None;
44010 return resultobj;
44011 fail:
44012 return NULL;
44013 }
44014
44015
44016 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44017 PyObject *resultobj;
44018 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44019 wxWindow *result;
44020 PyObject * obj0 = 0 ;
44021 char *kwnames[] = {
44022 (char *) "self", NULL
44023 };
44024
44025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44027 if (SWIG_arg_fail(1)) SWIG_fail;
44028 {
44029 PyThreadState* __tstate = wxPyBeginAllowThreads();
44030 result = (wxWindow *)(arg1)->GetOtherWindow();
44031
44032 wxPyEndAllowThreads(__tstate);
44033 if (PyErr_Occurred()) SWIG_fail;
44034 }
44035 {
44036 resultobj = wxPyMake_wxObject(result, 0);
44037 }
44038 return resultobj;
44039 fail:
44040 return NULL;
44041 }
44042
44043
44044 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44045 PyObject *resultobj;
44046 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44047 wxEdge result;
44048 PyObject * obj0 = 0 ;
44049 char *kwnames[] = {
44050 (char *) "self", NULL
44051 };
44052
44053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44055 if (SWIG_arg_fail(1)) SWIG_fail;
44056 {
44057 PyThreadState* __tstate = wxPyBeginAllowThreads();
44058 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44059
44060 wxPyEndAllowThreads(__tstate);
44061 if (PyErr_Occurred()) SWIG_fail;
44062 }
44063 resultobj = SWIG_From_int((result));
44064 return resultobj;
44065 fail:
44066 return NULL;
44067 }
44068
44069
44070 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44071 PyObject *resultobj;
44072 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44073 wxEdge arg2 ;
44074 PyObject * obj0 = 0 ;
44075 PyObject * obj1 = 0 ;
44076 char *kwnames[] = {
44077 (char *) "self",(char *) "which", NULL
44078 };
44079
44080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44082 if (SWIG_arg_fail(1)) SWIG_fail;
44083 {
44084 arg2 = (wxEdge)(SWIG_As_int(obj1));
44085 if (SWIG_arg_fail(2)) SWIG_fail;
44086 }
44087 {
44088 PyThreadState* __tstate = wxPyBeginAllowThreads();
44089 (arg1)->SetEdge((wxEdge )arg2);
44090
44091 wxPyEndAllowThreads(__tstate);
44092 if (PyErr_Occurred()) SWIG_fail;
44093 }
44094 Py_INCREF(Py_None); resultobj = Py_None;
44095 return resultobj;
44096 fail:
44097 return NULL;
44098 }
44099
44100
44101 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44102 PyObject *resultobj;
44103 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44104 int arg2 ;
44105 PyObject * obj0 = 0 ;
44106 PyObject * obj1 = 0 ;
44107 char *kwnames[] = {
44108 (char *) "self",(char *) "v", NULL
44109 };
44110
44111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44113 if (SWIG_arg_fail(1)) SWIG_fail;
44114 {
44115 arg2 = (int)(SWIG_As_int(obj1));
44116 if (SWIG_arg_fail(2)) SWIG_fail;
44117 }
44118 {
44119 PyThreadState* __tstate = wxPyBeginAllowThreads();
44120 (arg1)->SetValue(arg2);
44121
44122 wxPyEndAllowThreads(__tstate);
44123 if (PyErr_Occurred()) SWIG_fail;
44124 }
44125 Py_INCREF(Py_None); resultobj = Py_None;
44126 return resultobj;
44127 fail:
44128 return NULL;
44129 }
44130
44131
44132 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44133 PyObject *resultobj;
44134 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44135 int result;
44136 PyObject * obj0 = 0 ;
44137 char *kwnames[] = {
44138 (char *) "self", NULL
44139 };
44140
44141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44143 if (SWIG_arg_fail(1)) SWIG_fail;
44144 {
44145 PyThreadState* __tstate = wxPyBeginAllowThreads();
44146 result = (int)(arg1)->GetMargin();
44147
44148 wxPyEndAllowThreads(__tstate);
44149 if (PyErr_Occurred()) SWIG_fail;
44150 }
44151 {
44152 resultobj = SWIG_From_int((int)(result));
44153 }
44154 return resultobj;
44155 fail:
44156 return NULL;
44157 }
44158
44159
44160 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44161 PyObject *resultobj;
44162 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44163 int arg2 ;
44164 PyObject * obj0 = 0 ;
44165 PyObject * obj1 = 0 ;
44166 char *kwnames[] = {
44167 (char *) "self",(char *) "m", NULL
44168 };
44169
44170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44172 if (SWIG_arg_fail(1)) SWIG_fail;
44173 {
44174 arg2 = (int)(SWIG_As_int(obj1));
44175 if (SWIG_arg_fail(2)) SWIG_fail;
44176 }
44177 {
44178 PyThreadState* __tstate = wxPyBeginAllowThreads();
44179 (arg1)->SetMargin(arg2);
44180
44181 wxPyEndAllowThreads(__tstate);
44182 if (PyErr_Occurred()) SWIG_fail;
44183 }
44184 Py_INCREF(Py_None); resultobj = Py_None;
44185 return resultobj;
44186 fail:
44187 return NULL;
44188 }
44189
44190
44191 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44192 PyObject *resultobj;
44193 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44194 int result;
44195 PyObject * obj0 = 0 ;
44196 char *kwnames[] = {
44197 (char *) "self", NULL
44198 };
44199
44200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44202 if (SWIG_arg_fail(1)) SWIG_fail;
44203 {
44204 PyThreadState* __tstate = wxPyBeginAllowThreads();
44205 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44206
44207 wxPyEndAllowThreads(__tstate);
44208 if (PyErr_Occurred()) SWIG_fail;
44209 }
44210 {
44211 resultobj = SWIG_From_int((int)(result));
44212 }
44213 return resultobj;
44214 fail:
44215 return NULL;
44216 }
44217
44218
44219 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44220 PyObject *resultobj;
44221 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44222 int result;
44223 PyObject * obj0 = 0 ;
44224 char *kwnames[] = {
44225 (char *) "self", NULL
44226 };
44227
44228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44230 if (SWIG_arg_fail(1)) SWIG_fail;
44231 {
44232 PyThreadState* __tstate = wxPyBeginAllowThreads();
44233 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44234
44235 wxPyEndAllowThreads(__tstate);
44236 if (PyErr_Occurred()) SWIG_fail;
44237 }
44238 {
44239 resultobj = SWIG_From_int((int)(result));
44240 }
44241 return resultobj;
44242 fail:
44243 return NULL;
44244 }
44245
44246
44247 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44248 PyObject *resultobj;
44249 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44250 int result;
44251 PyObject * obj0 = 0 ;
44252 char *kwnames[] = {
44253 (char *) "self", NULL
44254 };
44255
44256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44258 if (SWIG_arg_fail(1)) SWIG_fail;
44259 {
44260 PyThreadState* __tstate = wxPyBeginAllowThreads();
44261 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44262
44263 wxPyEndAllowThreads(__tstate);
44264 if (PyErr_Occurred()) SWIG_fail;
44265 }
44266 {
44267 resultobj = SWIG_From_int((int)(result));
44268 }
44269 return resultobj;
44270 fail:
44271 return NULL;
44272 }
44273
44274
44275 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44276 PyObject *resultobj;
44277 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44278 bool result;
44279 PyObject * obj0 = 0 ;
44280 char *kwnames[] = {
44281 (char *) "self", NULL
44282 };
44283
44284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44286 if (SWIG_arg_fail(1)) SWIG_fail;
44287 {
44288 PyThreadState* __tstate = wxPyBeginAllowThreads();
44289 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44290
44291 wxPyEndAllowThreads(__tstate);
44292 if (PyErr_Occurred()) SWIG_fail;
44293 }
44294 {
44295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44296 }
44297 return resultobj;
44298 fail:
44299 return NULL;
44300 }
44301
44302
44303 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44304 PyObject *resultobj;
44305 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44306 bool arg2 ;
44307 PyObject * obj0 = 0 ;
44308 PyObject * obj1 = 0 ;
44309 char *kwnames[] = {
44310 (char *) "self",(char *) "d", NULL
44311 };
44312
44313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44315 if (SWIG_arg_fail(1)) SWIG_fail;
44316 {
44317 arg2 = (bool)(SWIG_As_bool(obj1));
44318 if (SWIG_arg_fail(2)) SWIG_fail;
44319 }
44320 {
44321 PyThreadState* __tstate = wxPyBeginAllowThreads();
44322 (arg1)->SetDone(arg2);
44323
44324 wxPyEndAllowThreads(__tstate);
44325 if (PyErr_Occurred()) SWIG_fail;
44326 }
44327 Py_INCREF(Py_None); resultobj = Py_None;
44328 return resultobj;
44329 fail:
44330 return NULL;
44331 }
44332
44333
44334 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44335 PyObject *resultobj;
44336 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44337 wxRelationship result;
44338 PyObject * obj0 = 0 ;
44339 char *kwnames[] = {
44340 (char *) "self", NULL
44341 };
44342
44343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44345 if (SWIG_arg_fail(1)) SWIG_fail;
44346 {
44347 PyThreadState* __tstate = wxPyBeginAllowThreads();
44348 result = (wxRelationship)(arg1)->GetRelationship();
44349
44350 wxPyEndAllowThreads(__tstate);
44351 if (PyErr_Occurred()) SWIG_fail;
44352 }
44353 resultobj = SWIG_From_int((result));
44354 return resultobj;
44355 fail:
44356 return NULL;
44357 }
44358
44359
44360 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44361 PyObject *resultobj;
44362 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44363 wxRelationship arg2 ;
44364 PyObject * obj0 = 0 ;
44365 PyObject * obj1 = 0 ;
44366 char *kwnames[] = {
44367 (char *) "self",(char *) "r", NULL
44368 };
44369
44370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44372 if (SWIG_arg_fail(1)) SWIG_fail;
44373 {
44374 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44375 if (SWIG_arg_fail(2)) SWIG_fail;
44376 }
44377 {
44378 PyThreadState* __tstate = wxPyBeginAllowThreads();
44379 (arg1)->SetRelationship((wxRelationship )arg2);
44380
44381 wxPyEndAllowThreads(__tstate);
44382 if (PyErr_Occurred()) SWIG_fail;
44383 }
44384 Py_INCREF(Py_None); resultobj = Py_None;
44385 return resultobj;
44386 fail:
44387 return NULL;
44388 }
44389
44390
44391 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44392 PyObject *resultobj;
44393 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44394 wxWindow *arg2 = (wxWindow *) 0 ;
44395 bool result;
44396 PyObject * obj0 = 0 ;
44397 PyObject * obj1 = 0 ;
44398 char *kwnames[] = {
44399 (char *) "self",(char *) "otherW", NULL
44400 };
44401
44402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44404 if (SWIG_arg_fail(1)) SWIG_fail;
44405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44406 if (SWIG_arg_fail(2)) SWIG_fail;
44407 {
44408 PyThreadState* __tstate = wxPyBeginAllowThreads();
44409 result = (bool)(arg1)->ResetIfWin(arg2);
44410
44411 wxPyEndAllowThreads(__tstate);
44412 if (PyErr_Occurred()) SWIG_fail;
44413 }
44414 {
44415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44416 }
44417 return resultobj;
44418 fail:
44419 return NULL;
44420 }
44421
44422
44423 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44424 PyObject *resultobj;
44425 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44426 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44427 wxWindow *arg3 = (wxWindow *) 0 ;
44428 bool result;
44429 PyObject * obj0 = 0 ;
44430 PyObject * obj1 = 0 ;
44431 PyObject * obj2 = 0 ;
44432 char *kwnames[] = {
44433 (char *) "self",(char *) "constraints",(char *) "win", NULL
44434 };
44435
44436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44438 if (SWIG_arg_fail(1)) SWIG_fail;
44439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44440 if (SWIG_arg_fail(2)) SWIG_fail;
44441 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44442 if (SWIG_arg_fail(3)) SWIG_fail;
44443 {
44444 PyThreadState* __tstate = wxPyBeginAllowThreads();
44445 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44446
44447 wxPyEndAllowThreads(__tstate);
44448 if (PyErr_Occurred()) SWIG_fail;
44449 }
44450 {
44451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44452 }
44453 return resultobj;
44454 fail:
44455 return NULL;
44456 }
44457
44458
44459 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44460 PyObject *resultobj;
44461 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44462 wxEdge arg2 ;
44463 wxWindow *arg3 = (wxWindow *) 0 ;
44464 wxWindow *arg4 = (wxWindow *) 0 ;
44465 int result;
44466 PyObject * obj0 = 0 ;
44467 PyObject * obj1 = 0 ;
44468 PyObject * obj2 = 0 ;
44469 PyObject * obj3 = 0 ;
44470 char *kwnames[] = {
44471 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44472 };
44473
44474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44476 if (SWIG_arg_fail(1)) SWIG_fail;
44477 {
44478 arg2 = (wxEdge)(SWIG_As_int(obj1));
44479 if (SWIG_arg_fail(2)) SWIG_fail;
44480 }
44481 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44482 if (SWIG_arg_fail(3)) SWIG_fail;
44483 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44484 if (SWIG_arg_fail(4)) SWIG_fail;
44485 {
44486 PyThreadState* __tstate = wxPyBeginAllowThreads();
44487 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44488
44489 wxPyEndAllowThreads(__tstate);
44490 if (PyErr_Occurred()) SWIG_fail;
44491 }
44492 {
44493 resultobj = SWIG_From_int((int)(result));
44494 }
44495 return resultobj;
44496 fail:
44497 return NULL;
44498 }
44499
44500
44501 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44502 PyObject *obj;
44503 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44504 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44505 Py_INCREF(obj);
44506 return Py_BuildValue((char *)"");
44507 }
44508 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44509 PyObject *resultobj;
44510 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44511 wxIndividualLayoutConstraint *result;
44512 PyObject * obj0 = 0 ;
44513 char *kwnames[] = {
44514 (char *) "self", NULL
44515 };
44516
44517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
44518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44519 if (SWIG_arg_fail(1)) SWIG_fail;
44520 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
44521
44522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44523 return resultobj;
44524 fail:
44525 return NULL;
44526 }
44527
44528
44529 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
44530 PyObject *resultobj;
44531 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44532 wxIndividualLayoutConstraint *result;
44533 PyObject * obj0 = 0 ;
44534 char *kwnames[] = {
44535 (char *) "self", NULL
44536 };
44537
44538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
44539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44540 if (SWIG_arg_fail(1)) SWIG_fail;
44541 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
44542
44543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44544 return resultobj;
44545 fail:
44546 return NULL;
44547 }
44548
44549
44550 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
44551 PyObject *resultobj;
44552 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44553 wxIndividualLayoutConstraint *result;
44554 PyObject * obj0 = 0 ;
44555 char *kwnames[] = {
44556 (char *) "self", NULL
44557 };
44558
44559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
44560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44561 if (SWIG_arg_fail(1)) SWIG_fail;
44562 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
44563
44564 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44565 return resultobj;
44566 fail:
44567 return NULL;
44568 }
44569
44570
44571 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
44572 PyObject *resultobj;
44573 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44574 wxIndividualLayoutConstraint *result;
44575 PyObject * obj0 = 0 ;
44576 char *kwnames[] = {
44577 (char *) "self", NULL
44578 };
44579
44580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
44581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44582 if (SWIG_arg_fail(1)) SWIG_fail;
44583 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
44584
44585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44586 return resultobj;
44587 fail:
44588 return NULL;
44589 }
44590
44591
44592 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
44593 PyObject *resultobj;
44594 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44595 wxIndividualLayoutConstraint *result;
44596 PyObject * obj0 = 0 ;
44597 char *kwnames[] = {
44598 (char *) "self", NULL
44599 };
44600
44601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
44602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44603 if (SWIG_arg_fail(1)) SWIG_fail;
44604 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
44605
44606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44607 return resultobj;
44608 fail:
44609 return NULL;
44610 }
44611
44612
44613 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44614 PyObject *resultobj;
44615 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44616 wxIndividualLayoutConstraint *result;
44617 PyObject * obj0 = 0 ;
44618 char *kwnames[] = {
44619 (char *) "self", NULL
44620 };
44621
44622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44624 if (SWIG_arg_fail(1)) SWIG_fail;
44625 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44626
44627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44628 return resultobj;
44629 fail:
44630 return NULL;
44631 }
44632
44633
44634 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44635 PyObject *resultobj;
44636 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44637 wxIndividualLayoutConstraint *result;
44638 PyObject * obj0 = 0 ;
44639 char *kwnames[] = {
44640 (char *) "self", NULL
44641 };
44642
44643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44645 if (SWIG_arg_fail(1)) SWIG_fail;
44646 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44647
44648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44649 return resultobj;
44650 fail:
44651 return NULL;
44652 }
44653
44654
44655 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44656 PyObject *resultobj;
44657 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44658 wxIndividualLayoutConstraint *result;
44659 PyObject * obj0 = 0 ;
44660 char *kwnames[] = {
44661 (char *) "self", NULL
44662 };
44663
44664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44666 if (SWIG_arg_fail(1)) SWIG_fail;
44667 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44668
44669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44670 return resultobj;
44671 fail:
44672 return NULL;
44673 }
44674
44675
44676 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44677 PyObject *resultobj;
44678 wxLayoutConstraints *result;
44679 char *kwnames[] = {
44680 NULL
44681 };
44682
44683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44684 {
44685 PyThreadState* __tstate = wxPyBeginAllowThreads();
44686 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44687
44688 wxPyEndAllowThreads(__tstate);
44689 if (PyErr_Occurred()) SWIG_fail;
44690 }
44691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44692 return resultobj;
44693 fail:
44694 return NULL;
44695 }
44696
44697
44698 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44699 PyObject *resultobj;
44700 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44701 wxWindow *arg2 = (wxWindow *) 0 ;
44702 int *arg3 = (int *) 0 ;
44703 bool result;
44704 int temp3 ;
44705 int res3 = 0 ;
44706 PyObject * obj0 = 0 ;
44707 PyObject * obj1 = 0 ;
44708 char *kwnames[] = {
44709 (char *) "self",(char *) "win", NULL
44710 };
44711
44712 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44715 if (SWIG_arg_fail(1)) SWIG_fail;
44716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44717 if (SWIG_arg_fail(2)) SWIG_fail;
44718 {
44719 PyThreadState* __tstate = wxPyBeginAllowThreads();
44720 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44721
44722 wxPyEndAllowThreads(__tstate);
44723 if (PyErr_Occurred()) SWIG_fail;
44724 }
44725 {
44726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44727 }
44728 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44729 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44730 return resultobj;
44731 fail:
44732 return NULL;
44733 }
44734
44735
44736 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44737 PyObject *resultobj;
44738 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44739 bool result;
44740 PyObject * obj0 = 0 ;
44741 char *kwnames[] = {
44742 (char *) "self", NULL
44743 };
44744
44745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44747 if (SWIG_arg_fail(1)) SWIG_fail;
44748 {
44749 PyThreadState* __tstate = wxPyBeginAllowThreads();
44750 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44751
44752 wxPyEndAllowThreads(__tstate);
44753 if (PyErr_Occurred()) SWIG_fail;
44754 }
44755 {
44756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44757 }
44758 return resultobj;
44759 fail:
44760 return NULL;
44761 }
44762
44763
44764 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44765 PyObject *obj;
44766 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44767 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44768 Py_INCREF(obj);
44769 return Py_BuildValue((char *)"");
44770 }
44771 static PyMethodDef SwigMethods[] = {
44772 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44773 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44774 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44777 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44785 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44798 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44811 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44826 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44879 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44907 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44926 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44928 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44936 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44937 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44949 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44961 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44965 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44971 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44981 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44991 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44995 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45045 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45070 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45072 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45074 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45076 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45078 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45080 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45082 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45084 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45086 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45088 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45090 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45092 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45094 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45099 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45102 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45108 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45126 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45129 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45132 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45144 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45149 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45155 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45157 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45161 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45184 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45214 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45222 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45224 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45231 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45241 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45242 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45267 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45277 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45283 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45285 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45287 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45290 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45294 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45297 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45300 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45302 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45307 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45315 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45319 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45322 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45324 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45328 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45345 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45347 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45350 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45352 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45356 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45360 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45371 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45374 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45377 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45381 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45388 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45393 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45398 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45402 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45447 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45467 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45474 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45478 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45488 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45658 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45698 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45712 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45715 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45770 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45797 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45841 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45849 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45867 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45868 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45869 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45906 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45936 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45939 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45943 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45946 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45956 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
45968 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45980 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45990 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46000 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46014 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46021 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46022 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46023 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46024 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46025 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46030 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46057 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46069 { NULL, NULL, 0, NULL }
46070 };
46071
46072
46073 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46074
46075 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46076 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46077 }
46078 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46079 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46080 }
46081 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46082 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46083 }
46084 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46085 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46086 }
46087 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46088 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46089 }
46090 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46091 return (void *)((wxSizer *) ((wxGridSizer *) x));
46092 }
46093 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46094 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46095 }
46096 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46097 return (void *)((wxSizer *) ((wxPySizer *) x));
46098 }
46099 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46100 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46101 }
46102 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46103 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46104 }
46105 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46106 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46107 }
46108 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46109 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46110 }
46111 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46112 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46113 }
46114 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46115 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46116 }
46117 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46118 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46119 }
46120 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46121 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46122 }
46123 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46124 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46125 }
46126 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46127 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46128 }
46129 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46130 return (void *)((wxEvent *) ((wxPyEvent *) x));
46131 }
46132 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46133 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46134 }
46135 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46136 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46137 }
46138 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46139 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46140 }
46141 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46142 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46143 }
46144 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46145 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46146 }
46147 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46148 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46149 }
46150 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46151 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46152 }
46153 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46154 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46155 }
46156 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46157 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46158 }
46159 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46160 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46161 }
46162 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46163 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46164 }
46165 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46166 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46167 }
46168 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46169 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46170 }
46171 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46172 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46173 }
46174 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46175 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46176 }
46177 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46178 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46179 }
46180 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46181 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46182 }
46183 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46184 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46185 }
46186 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46187 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46188 }
46189 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46190 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46191 }
46192 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46193 return (void *)((wxEvent *) ((wxShowEvent *) x));
46194 }
46195 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46196 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46197 }
46198 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46199 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46200 }
46201 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46202 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46203 }
46204 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46205 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46206 }
46207 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46208 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46209 }
46210 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46211 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46212 }
46213 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46214 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46215 }
46216 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46217 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46218 }
46219 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46220 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46221 }
46222 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46223 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46224 }
46225 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46226 return (void *)((wxControl *) ((wxControlWithItems *) x));
46227 }
46228 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46229 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46230 }
46231 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46232 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46233 }
46234 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46235 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46236 }
46237 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46238 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46239 }
46240 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46241 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46242 }
46243 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46244 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46245 }
46246 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46247 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46248 }
46249 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46250 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46251 }
46252 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46253 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46254 }
46255 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46256 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46257 }
46258 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46259 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46260 }
46261 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46262 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46263 }
46264 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46265 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46266 }
46267 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46268 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46269 }
46270 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46271 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46272 }
46273 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46274 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46275 }
46276 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46277 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46278 }
46279 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46280 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46281 }
46282 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46283 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46284 }
46285 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46286 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46287 }
46288 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46289 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46290 }
46291 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46292 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46293 }
46294 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46295 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46296 }
46297 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46298 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46299 }
46300 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46301 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46302 }
46303 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46304 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46305 }
46306 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46307 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46308 }
46309 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46310 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46311 }
46312 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46313 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46314 }
46315 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46316 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46317 }
46318 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46319 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46320 }
46321 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46322 return (void *)((wxObject *) ((wxSizerItem *) x));
46323 }
46324 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46325 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46326 }
46327 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46328 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46329 }
46330 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46331 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46332 }
46333 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46334 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46335 }
46336 static void *_p_wxSizerTo_p_wxObject(void *x) {
46337 return (void *)((wxObject *) ((wxSizer *) x));
46338 }
46339 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46340 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46341 }
46342 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46343 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46344 }
46345 static void *_p_wxEventTo_p_wxObject(void *x) {
46346 return (void *)((wxObject *) ((wxEvent *) x));
46347 }
46348 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46349 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46350 }
46351 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46352 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46353 }
46354 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46355 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46356 }
46357 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46358 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46359 }
46360 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46361 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46362 }
46363 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46364 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46365 }
46366 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46367 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46368 }
46369 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46370 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46371 }
46372 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46373 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46374 }
46375 static void *_p_wxControlTo_p_wxObject(void *x) {
46376 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46377 }
46378 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46379 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46380 }
46381 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46382 return (void *)((wxObject *) ((wxFSFile *) x));
46383 }
46384 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46385 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46386 }
46387 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46388 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46389 }
46390 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46391 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46392 }
46393 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46394 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46395 }
46396 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46397 return (void *)((wxObject *) ((wxMenuItem *) x));
46398 }
46399 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46400 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46401 }
46402 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46403 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46404 }
46405 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46406 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46407 }
46408 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46409 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46410 }
46411 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46412 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46413 }
46414 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46415 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46416 }
46417 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46418 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46419 }
46420 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46421 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46422 }
46423 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46424 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46425 }
46426 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46427 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46428 }
46429 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46430 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46431 }
46432 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46433 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46434 }
46435 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46436 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46437 }
46438 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46439 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46440 }
46441 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46442 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46443 }
46444 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46445 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46446 }
46447 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46448 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46449 }
46450 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46451 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46452 }
46453 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46454 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46455 }
46456 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46457 return (void *)((wxObject *) ((wxImageHandler *) x));
46458 }
46459 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46460 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46461 }
46462 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46463 return (void *)((wxObject *) ((wxEvtHandler *) x));
46464 }
46465 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46466 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46467 }
46468 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46469 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46470 }
46471 static void *_p_wxImageTo_p_wxObject(void *x) {
46472 return (void *)((wxObject *) ((wxImage *) x));
46473 }
46474 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46475 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46476 }
46477 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46478 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46479 }
46480 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46481 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46482 }
46483 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46484 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46485 }
46486 static void *_p_wxWindowTo_p_wxObject(void *x) {
46487 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46488 }
46489 static void *_p_wxMenuTo_p_wxObject(void *x) {
46490 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46491 }
46492 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46493 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46494 }
46495 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46496 return (void *)((wxObject *) ((wxFileSystem *) x));
46497 }
46498 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46499 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46500 }
46501 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46502 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46503 }
46504 static void *_p_wxPyAppTo_p_wxObject(void *x) {
46505 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
46506 }
46507 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
46508 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
46509 }
46510 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
46511 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
46512 }
46513 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
46514 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
46515 }
46516 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
46517 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
46518 }
46519 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
46520 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
46521 }
46522 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
46523 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
46524 }
46525 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
46526 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
46527 }
46528 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
46529 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
46530 }
46531 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
46532 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46533 }
46534 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
46535 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
46536 }
46537 static void *_p_wxValidatorTo_p_wxObject(void *x) {
46538 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
46539 }
46540 static void *_p_wxControlTo_p_wxWindow(void *x) {
46541 return (void *)((wxWindow *) ((wxControl *) x));
46542 }
46543 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
46544 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
46545 }
46546 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
46547 return (void *)((wxWindow *) ((wxMenuBar *) x));
46548 }
46549 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
46550 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
46551 }
46552 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
46553 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
46554 }
46555 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
46556 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
46557 }
46558 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
46559 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
46560 }
46561 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
46562 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
46563 }
46564 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
46565 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46566 }
46567 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
46568 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
46569 }
46570 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
46571 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
46572 }
46573 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
46574 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
46575 }
46576 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
46577 return (void *)((wxValidator *) ((wxPyValidator *) x));
46578 }
46579 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}};
46580 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}};
46581 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}};
46582 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}};
46583 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}};
46584 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}};
46585 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}};
46586 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}};
46587 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}};
46588 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}};
46589 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}};
46590 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}};
46591 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}};
46592 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}};
46593 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}};
46594 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}};
46595 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}};
46596 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}};
46597 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}};
46598 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}};
46599 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}};
46600 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}};
46601 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}};
46602 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}};
46603 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}};
46604 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}};
46605 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}};
46606 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}};
46607 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}};
46608 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}};
46609 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}};
46610 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}};
46611 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}};
46612 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}};
46613 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}};
46614 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}};
46615 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}};
46616 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}};
46617 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}};
46618 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}};
46619 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}};
46620 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}};
46621 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}};
46622 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}};
46623 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}};
46624 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}};
46625 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}};
46626 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}};
46627 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}};
46628 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}};
46629 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}};
46630 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}};
46631 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}};
46632 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}};
46633 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}};
46634 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}};
46635 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}};
46636 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}};
46637 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}};
46638 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}};
46639 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}};
46640 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}};
46641 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}};
46642 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}};
46643 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}};
46644 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}};
46645 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}};
46646 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}};
46647 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}};
46648 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}};
46649 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}};
46650 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}};
46651 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}};
46652 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}};
46653 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}};
46654 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}};
46655 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}};
46656 static swig_type_info _swigt__p_wxImageHandler[] = {{"_p_wxImageHandler", 0, "wxImageHandler *", 0, 0, 0, 0},{"_p_wxImageHandler", 0, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46657 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}};
46658 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}};
46659 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}};
46660 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}};
46661 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}};
46662 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}};
46663 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}};
46664 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}};
46665 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}};
46666 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}};
46667 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}};
46668 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}};
46669 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}};
46670 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}};
46671 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}};
46672 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}};
46673 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDateEvent", _p_wxDateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46674 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}};
46675 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}};
46676 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}};
46677 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}};
46678 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}};
46679 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}};
46680 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}};
46681 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}};
46682 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}};
46683 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}};
46684 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}};
46685 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}};
46686 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}};
46687 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}};
46688 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}};
46689 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}};
46690 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}};
46691 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}};
46692 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}};
46693 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}};
46694 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}};
46695 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}};
46696 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}};
46697 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}};
46698 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}};
46699 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}};
46700 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}};
46701 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}};
46702 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}};
46703 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}};
46704 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}};
46705 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}};
46706
46707 static swig_type_info *swig_types_initial[] = {
46708 _swigt__p_wxLayoutConstraints,
46709 _swigt__p_wxRealPoint,
46710 _swigt__p_wxSizerItem,
46711 _swigt__p_wxGBSizerItem,
46712 _swigt__p_wxScrollEvent,
46713 _swigt__p_wxEventLoop,
46714 _swigt__p_wxIndividualLayoutConstraint,
46715 _swigt__p_wxSizer,
46716 _swigt__p_wxBoxSizer,
46717 _swigt__p_wxStaticBoxSizer,
46718 _swigt__p_wxGridBagSizer,
46719 _swigt__p_wxAcceleratorEntry,
46720 _swigt__p_wxUpdateUIEvent,
46721 _swigt__p_wxEvent,
46722 _swigt__p_wxMenu,
46723 _swigt__p_wxGridSizer,
46724 _swigt__p_wxFlexGridSizer,
46725 _swigt__p_wxInitDialogEvent,
46726 _swigt__p_wxItemContainer,
46727 _swigt__p_wxNcPaintEvent,
46728 _swigt__p_wxPaintEvent,
46729 _swigt__p_wxSysColourChangedEvent,
46730 _swigt__p_wxMouseCaptureChangedEvent,
46731 _swigt__p_wxDisplayChangedEvent,
46732 _swigt__p_wxPaletteChangedEvent,
46733 _swigt__p_wxControl,
46734 _swigt__p_wxFont,
46735 _swigt__p_wxMenuBarBase,
46736 _swigt__p_wxSetCursorEvent,
46737 _swigt__p_wxFSFile,
46738 _swigt__p_wxCaret,
46739 _swigt__ptrdiff_t,
46740 _swigt__std__ptrdiff_t,
46741 _swigt__p_wxRegion,
46742 _swigt__p_wxPoint2D,
46743 _swigt__p_int,
46744 _swigt__p_wxSize,
46745 _swigt__p_wxDC,
46746 _swigt__p_wxPySizer,
46747 _swigt__p_wxVisualAttributes,
46748 _swigt__p_wxNotifyEvent,
46749 _swigt__p_wxPyEvent,
46750 _swigt__p_wxPropagationDisabler,
46751 _swigt__p_form_ops_t,
46752 _swigt__p_wxAppTraits,
46753 _swigt__p_wxArrayString,
46754 _swigt__p_wxShowEvent,
46755 _swigt__p_wxToolTip,
46756 _swigt__p_wxMoveEvent,
46757 _swigt__p_wxSizeEvent,
46758 _swigt__p_wxActivateEvent,
46759 _swigt__p_wxIconizeEvent,
46760 _swigt__p_wxMaximizeEvent,
46761 _swigt__p_wxQueryNewPaletteEvent,
46762 _swigt__p_wxWindowCreateEvent,
46763 _swigt__p_wxIdleEvent,
46764 _swigt__p_wxDateEvent,
46765 _swigt__p_wxMenuItem,
46766 _swigt__p_wxStaticBox,
46767 _swigt__p_long,
46768 _swigt__p_wxDuplexMode,
46769 _swigt__p_wxTIFFHandler,
46770 _swigt__p_wxXPMHandler,
46771 _swigt__p_wxPNMHandler,
46772 _swigt__p_wxJPEGHandler,
46773 _swigt__p_wxPCXHandler,
46774 _swigt__p_wxGIFHandler,
46775 _swigt__p_wxPNGHandler,
46776 _swigt__p_wxANIHandler,
46777 _swigt__p_wxMemoryFSHandler,
46778 _swigt__p_wxZipFSHandler,
46779 _swigt__p_wxInternetFSHandler,
46780 _swigt__p_wxPyFileSystemHandler,
46781 _swigt__p_wxEvtHandler,
46782 _swigt__p_wxCURHandler,
46783 _swigt__p_wxICOHandler,
46784 _swigt__p_wxBMPHandler,
46785 _swigt__p_wxImageHandler,
46786 _swigt__p_wxFileSystemHandler,
46787 _swigt__p_wxRect,
46788 _swigt__p_wxButton,
46789 _swigt__p_wxGBSpan,
46790 _swigt__p_wxPropagateOnce,
46791 _swigt__p_wxAcceleratorTable,
46792 _swigt__p_wxStdDialogButtonSizer,
46793 _swigt__p_char,
46794 _swigt__p_wxGBPosition,
46795 _swigt__p_wxImage,
46796 _swigt__p_wxFrame,
46797 _swigt__p_wxScrollWinEvent,
46798 _swigt__p_wxPaperSize,
46799 _swigt__p_wxImageHistogram,
46800 _swigt__p_wxPoint,
46801 _swigt__p_wxCursor,
46802 _swigt__p_wxObject,
46803 _swigt__p_wxInputStream,
46804 _swigt__p_wxOutputStream,
46805 _swigt__p_wxPyInputStream,
46806 _swigt__p_wxDateTime,
46807 _swigt__p_wxKeyEvent,
46808 _swigt__p_wxNavigationKeyEvent,
46809 _swigt__p_wxWindowDestroyEvent,
46810 _swigt__p_unsigned_long,
46811 _swigt__p_wxWindow,
46812 _swigt__p_wxMenuBar,
46813 _swigt__p_wxFileSystem,
46814 _swigt__p_wxBitmap,
46815 _swigt__unsigned_int,
46816 _swigt__p_unsigned_int,
46817 _swigt__p_wxMenuEvent,
46818 _swigt__p_wxContextMenuEvent,
46819 _swigt__p_unsigned_char,
46820 _swigt__p_wxEraseEvent,
46821 _swigt__p_wxMouseEvent,
46822 _swigt__p_wxCloseEvent,
46823 _swigt__p_wxPyApp,
46824 _swigt__p_wxCommandEvent,
46825 _swigt__p_wxPyCommandEvent,
46826 _swigt__p_wxPyDropTarget,
46827 _swigt__p_wxQuantize,
46828 _swigt__p_wxChildFocusEvent,
46829 _swigt__p_wxFocusEvent,
46830 _swigt__p_wxDropFilesEvent,
46831 _swigt__p_wxControlWithItems,
46832 _swigt__p_wxColour,
46833 _swigt__p_wxValidator,
46834 _swigt__p_wxPyValidator,
46835 0
46836 };
46837
46838
46839 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46840
46841 static swig_const_info swig_const_table[] = {
46842 {0, 0, 0, 0.0, 0, 0}};
46843
46844 #ifdef __cplusplus
46845 }
46846 #endif
46847
46848
46849 #ifdef __cplusplus
46850 extern "C" {
46851 #endif
46852
46853 /* Python-specific SWIG API */
46854 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46855 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46856 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46857
46858 /* -----------------------------------------------------------------------------
46859 * global variable support code.
46860 * ----------------------------------------------------------------------------- */
46861
46862 typedef struct swig_globalvar {
46863 char *name; /* Name of global variable */
46864 PyObject *(*get_attr)(); /* Return the current value */
46865 int (*set_attr)(PyObject *); /* Set the value */
46866 struct swig_globalvar *next;
46867 } swig_globalvar;
46868
46869 typedef struct swig_varlinkobject {
46870 PyObject_HEAD
46871 swig_globalvar *vars;
46872 } swig_varlinkobject;
46873
46874 static PyObject *
46875 swig_varlink_repr(swig_varlinkobject *v) {
46876 v = v;
46877 return PyString_FromString("<Swig global variables>");
46878 }
46879
46880 static int
46881 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46882 swig_globalvar *var;
46883 flags = flags;
46884 fprintf(fp,"Swig global variables { ");
46885 for (var = v->vars; var; var=var->next) {
46886 fprintf(fp,"%s", var->name);
46887 if (var->next) fprintf(fp,", ");
46888 }
46889 fprintf(fp," }\n");
46890 return 0;
46891 }
46892
46893 static PyObject *
46894 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46895 swig_globalvar *var = v->vars;
46896 while (var) {
46897 if (strcmp(var->name,n) == 0) {
46898 return (*var->get_attr)();
46899 }
46900 var = var->next;
46901 }
46902 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46903 return NULL;
46904 }
46905
46906 static int
46907 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46908 swig_globalvar *var = v->vars;
46909 while (var) {
46910 if (strcmp(var->name,n) == 0) {
46911 return (*var->set_attr)(p);
46912 }
46913 var = var->next;
46914 }
46915 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46916 return 1;
46917 }
46918
46919 static PyTypeObject varlinktype = {
46920 PyObject_HEAD_INIT(0)
46921 0, /* Number of items in variable part (ob_size) */
46922 (char *)"swigvarlink", /* Type name (tp_name) */
46923 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46924 0, /* Itemsize (tp_itemsize) */
46925 0, /* Deallocator (tp_dealloc) */
46926 (printfunc) swig_varlink_print, /* Print (tp_print) */
46927 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46928 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46929 0, /* tp_compare */
46930 (reprfunc) swig_varlink_repr, /* tp_repr */
46931 0, /* tp_as_number */
46932 0, /* tp_as_sequence */
46933 0, /* tp_as_mapping */
46934 0, /* tp_hash */
46935 0, /* tp_call */
46936 0, /* tp_str */
46937 0, /* tp_getattro */
46938 0, /* tp_setattro */
46939 0, /* tp_as_buffer */
46940 0, /* tp_flags */
46941 0, /* tp_doc */
46942 #if PY_VERSION_HEX >= 0x02000000
46943 0, /* tp_traverse */
46944 0, /* tp_clear */
46945 #endif
46946 #if PY_VERSION_HEX >= 0x02010000
46947 0, /* tp_richcompare */
46948 0, /* tp_weaklistoffset */
46949 #endif
46950 #if PY_VERSION_HEX >= 0x02020000
46951 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46952 #endif
46953 #if PY_VERSION_HEX >= 0x02030000
46954 0, /* tp_del */
46955 #endif
46956 #ifdef COUNT_ALLOCS
46957 0,0,0,0 /* tp_alloc -> tp_next */
46958 #endif
46959 };
46960
46961 /* Create a variable linking object for use later */
46962 static PyObject *
46963 SWIG_Python_newvarlink(void) {
46964 swig_varlinkobject *result = 0;
46965 result = PyMem_NEW(swig_varlinkobject,1);
46966 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
46967 result->ob_type = &varlinktype;
46968 result->vars = 0;
46969 result->ob_refcnt = 0;
46970 Py_XINCREF((PyObject *) result);
46971 return ((PyObject*) result);
46972 }
46973
46974 static void
46975 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
46976 swig_varlinkobject *v;
46977 swig_globalvar *gv;
46978 v= (swig_varlinkobject *) p;
46979 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46980 gv->name = (char *) malloc(strlen(name)+1);
46981 strcpy(gv->name,name);
46982 gv->get_attr = get_attr;
46983 gv->set_attr = set_attr;
46984 gv->next = v->vars;
46985 v->vars = gv;
46986 }
46987
46988 /* -----------------------------------------------------------------------------
46989 * constants/methods manipulation
46990 * ----------------------------------------------------------------------------- */
46991
46992 /* Install Constants */
46993 static void
46994 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46995 PyObject *obj = 0;
46996 size_t i;
46997 for (i = 0; constants[i].type; i++) {
46998 switch(constants[i].type) {
46999 case SWIG_PY_INT:
47000 obj = PyInt_FromLong(constants[i].lvalue);
47001 break;
47002 case SWIG_PY_FLOAT:
47003 obj = PyFloat_FromDouble(constants[i].dvalue);
47004 break;
47005 case SWIG_PY_STRING:
47006 if (constants[i].pvalue) {
47007 obj = PyString_FromString((char *) constants[i].pvalue);
47008 } else {
47009 Py_INCREF(Py_None);
47010 obj = Py_None;
47011 }
47012 break;
47013 case SWIG_PY_POINTER:
47014 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47015 break;
47016 case SWIG_PY_BINARY:
47017 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47018 break;
47019 default:
47020 obj = 0;
47021 break;
47022 }
47023 if (obj) {
47024 PyDict_SetItemString(d,constants[i].name,obj);
47025 Py_DECREF(obj);
47026 }
47027 }
47028 }
47029
47030 /* -----------------------------------------------------------------------------*/
47031 /* Fix SwigMethods to carry the callback ptrs when needed */
47032 /* -----------------------------------------------------------------------------*/
47033
47034 static void
47035 SWIG_Python_FixMethods(PyMethodDef *methods,
47036 swig_const_info *const_table,
47037 swig_type_info **types,
47038 swig_type_info **types_initial) {
47039 size_t i;
47040 for (i = 0; methods[i].ml_name; ++i) {
47041 char *c = methods[i].ml_doc;
47042 if (c && (c = strstr(c, "swig_ptr: "))) {
47043 int j;
47044 swig_const_info *ci = 0;
47045 char *name = c + 10;
47046 for (j = 0; const_table[j].type; j++) {
47047 if (strncmp(const_table[j].name, name,
47048 strlen(const_table[j].name)) == 0) {
47049 ci = &(const_table[j]);
47050 break;
47051 }
47052 }
47053 if (ci) {
47054 size_t shift = (ci->ptype) - types;
47055 swig_type_info *ty = types_initial[shift];
47056 size_t ldoc = (c - methods[i].ml_doc);
47057 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47058 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47059 char *buff = ndoc;
47060 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47061 strncpy(buff, methods[i].ml_doc, ldoc);
47062 buff += ldoc;
47063 strncpy(buff, "swig_ptr: ", 10);
47064 buff += 10;
47065 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47066 methods[i].ml_doc = ndoc;
47067 }
47068 }
47069 }
47070 }
47071
47072 /* -----------------------------------------------------------------------------*
47073 * Initialize type list
47074 * -----------------------------------------------------------------------------*/
47075
47076 #if PY_MAJOR_VERSION < 2
47077 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47078 is copied out of Python/modsupport.c in python version 2.3.4 */
47079 static int
47080 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47081 {
47082 PyObject *dict;
47083 if (!PyModule_Check(m)) {
47084 PyErr_SetString(PyExc_TypeError,
47085 "PyModule_AddObject() needs module as first arg");
47086 return -1;
47087 }
47088 if (!o) {
47089 PyErr_SetString(PyExc_TypeError,
47090 "PyModule_AddObject() needs non-NULL value");
47091 return -1;
47092 }
47093
47094 dict = PyModule_GetDict(m);
47095 if (dict == NULL) {
47096 /* Internal error -- modules must have a dict! */
47097 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47098 PyModule_GetName(m));
47099 return -1;
47100 }
47101 if (PyDict_SetItemString(dict, name, o))
47102 return -1;
47103 Py_DECREF(o);
47104 return 0;
47105 }
47106 #endif
47107
47108 static swig_type_info **
47109 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47110 static PyMethodDef swig_empty_runtime_method_table[] = {
47111 {
47112 NULL, NULL, 0, NULL
47113 }
47114 };/* Sentinel */
47115
47116 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47117 swig_empty_runtime_method_table);
47118 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47119 if (pointer && module) {
47120 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47121 }
47122 return type_list_handle;
47123 }
47124
47125 static swig_type_info **
47126 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47127 swig_type_info **type_pointer;
47128
47129 /* first check if module already created */
47130 type_pointer = SWIG_Python_GetTypeListHandle();
47131 if (type_pointer) {
47132 return type_pointer;
47133 } else {
47134 /* create a new module and variable */
47135 return SWIG_Python_SetTypeListHandle(type_list_handle);
47136 }
47137 }
47138
47139 #ifdef __cplusplus
47140 }
47141 #endif
47142
47143 /* -----------------------------------------------------------------------------*
47144 * Partial Init method
47145 * -----------------------------------------------------------------------------*/
47146
47147 #ifdef SWIG_LINK_RUNTIME
47148 #ifdef __cplusplus
47149 extern "C"
47150 #endif
47151 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47152 #endif
47153
47154 #ifdef __cplusplus
47155 extern "C"
47156 #endif
47157 SWIGEXPORT(void) SWIG_init(void) {
47158 static PyObject *SWIG_globals = 0;
47159 static int typeinit = 0;
47160 PyObject *m, *d;
47161 int i;
47162 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47163
47164 /* Fix SwigMethods to carry the callback ptrs when needed */
47165 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47166
47167 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47168 d = PyModule_GetDict(m);
47169
47170 if (!typeinit) {
47171 #ifdef SWIG_LINK_RUNTIME
47172 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47173 #else
47174 # ifndef SWIG_STATIC_RUNTIME
47175 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47176 # endif
47177 #endif
47178 for (i = 0; swig_types_initial[i]; i++) {
47179 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47180 }
47181 typeinit = 1;
47182 }
47183 SWIG_InstallConstants(d,swig_const_table);
47184
47185
47186 #ifndef wxPyUSE_EXPORT
47187 // Make our API structure a CObject so other modules can import it
47188 // from this module.
47189 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47190 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47191 Py_XDECREF(cobj);
47192 #endif
47193
47194 {
47195 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47196 }
47197 {
47198 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47199 }
47200 {
47201 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47202 }
47203 {
47204 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47205 }
47206 {
47207 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47208 }
47209 {
47210 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47211 }
47212 {
47213 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47214 }
47215 {
47216 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47217 }
47218 {
47219 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47220 }
47221 {
47222 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47223 }
47224 {
47225 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47226 }
47227 {
47228 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47229 }
47230 {
47231 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47232 }
47233 {
47234 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47235 }
47236 {
47237 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47238 }
47239 {
47240 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47241 }
47242 {
47243 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47244 }
47245 {
47246 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47247 }
47248 {
47249 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
47250 }
47251 {
47252 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
47253 }
47254 {
47255 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
47256 }
47257 {
47258 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
47259 }
47260 {
47261 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
47262 }
47263 {
47264 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47265 }
47266 {
47267 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47268 }
47269 {
47270 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47271 }
47272 {
47273 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47274 }
47275 {
47276 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47277 }
47278 {
47279 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47280 }
47281 {
47282 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47283 }
47284 {
47285 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47286 }
47287 {
47288 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47289 }
47290 {
47291 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47292 }
47293 {
47294 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47295 }
47296 {
47297 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47298 }
47299 {
47300 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47301 }
47302 {
47303 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47304 }
47305 {
47306 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47307 }
47308 {
47309 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47310 }
47311 {
47312 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47313 }
47314 {
47315 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47316 }
47317 {
47318 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47319 }
47320 {
47321 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47322 }
47323 {
47324 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47325 }
47326 {
47327 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47328 }
47329 {
47330 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47331 }
47332 {
47333 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47334 }
47335 {
47336 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47337 }
47338 {
47339 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47340 }
47341 {
47342 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47343 }
47344 {
47345 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47346 }
47347 {
47348 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47349 }
47350 {
47351 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47352 }
47353 {
47354 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47355 }
47356 {
47357 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47358 }
47359 {
47360 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47361 }
47362 {
47363 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47364 }
47365 {
47366 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47367 }
47368 {
47369 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47370 }
47371 {
47372 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47373 }
47374 {
47375 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47376 }
47377 {
47378 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47379 }
47380 {
47381 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47382 }
47383 {
47384 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47385 }
47386 {
47387 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47388 }
47389 {
47390 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47391 }
47392 {
47393 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47394 }
47395 {
47396 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47397 }
47398 {
47399 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47400 }
47401 {
47402 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47403 }
47404 {
47405 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47406 }
47407 {
47408 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47409 }
47410 {
47411 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47412 }
47413 {
47414 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47415 }
47416 {
47417 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47418 }
47419 {
47420 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47421 }
47422 {
47423 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47424 }
47425 {
47426 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47427 }
47428 {
47429 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47430 }
47431 {
47432 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47433 }
47434 {
47435 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47436 }
47437 {
47438 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47439 }
47440 {
47441 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47442 }
47443 {
47444 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47445 }
47446 {
47447 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47448 }
47449 {
47450 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47451 }
47452 {
47453 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47454 }
47455 {
47456 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47457 }
47458 {
47459 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47460 }
47461 {
47462 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47463 }
47464 {
47465 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47466 }
47467 {
47468 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47469 }
47470 {
47471 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47472 }
47473 {
47474 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47475 }
47476 {
47477 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47478 }
47479 {
47480 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47481 }
47482 {
47483 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47484 }
47485 {
47486 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47487 }
47488 {
47489 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47490 }
47491 {
47492 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47493 }
47494 {
47495 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47496 }
47497 {
47498 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47499 }
47500 {
47501 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47502 }
47503 {
47504 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47505 }
47506 {
47507 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47508 }
47509 {
47510 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47511 }
47512 {
47513 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47514 }
47515 {
47516 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
47517 }
47518 {
47519 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
47520 }
47521 {
47522 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
47523 }
47524 {
47525 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
47526 }
47527 {
47528 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
47529 }
47530 {
47531 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
47532 }
47533 {
47534 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
47535 }
47536 {
47537 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
47538 }
47539 {
47540 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
47541 }
47542 {
47543 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
47544 }
47545 {
47546 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
47547 }
47548 {
47549 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
47550 }
47551 {
47552 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
47553 }
47554 {
47555 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
47556 }
47557 {
47558 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
47559 }
47560 {
47561 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
47562 }
47563 {
47564 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
47565 }
47566 {
47567 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
47568 }
47569 {
47570 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
47571 }
47572 {
47573 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
47574 }
47575 {
47576 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
47577 }
47578 {
47579 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
47580 }
47581 {
47582 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
47583 }
47584 {
47585 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
47586 }
47587 {
47588 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
47589 }
47590 {
47591 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
47592 }
47593 {
47594 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
47595 }
47596 {
47597 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
47598 }
47599 {
47600 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
47601 }
47602 {
47603 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
47604 }
47605 {
47606 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
47607 }
47608 {
47609 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
47610 }
47611 {
47612 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
47613 }
47614 {
47615 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
47616 }
47617 {
47618 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
47619 }
47620 {
47621 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
47622 }
47623 {
47624 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
47625 }
47626 {
47627 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47628 }
47629 {
47630 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47631 }
47632 {
47633 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47634 }
47635 {
47636 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47637 }
47638 {
47639 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47640 }
47641 {
47642 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47643 }
47644 {
47645 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47646 }
47647 {
47648 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47649 }
47650 {
47651 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47652 }
47653 {
47654 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47655 }
47656 {
47657 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47658 }
47659 {
47660 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47661 }
47662 {
47663 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47664 }
47665 {
47666 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47667 }
47668 {
47669 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47670 }
47671 {
47672 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47673 }
47674 {
47675 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48798 }
48799 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48800 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48801 {
48802 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48836 }
48837 {
48838 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48839 }
48840 {
48841 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48842 }
48843 {
48844 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48845 }
48846 {
48847 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48848 }
48849 {
48850 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48851 }
48852 {
48853 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48854 }
48855 {
48856 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48857 }
48858 {
48859 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48860 }
48861 {
48862 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48863 }
48864 {
48865 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48866 }
48867 {
48868 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48869 }
48870 {
48871 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48872 }
48873 {
48874 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48875 }
48876 {
48877 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48884 }
48885 {
48886 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48887 }
48888 {
48889 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48890 }
48891 {
48892 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48893 }
48894 {
48895 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48896 }
48897 {
48898 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48899 }
48900 {
48901 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48902 }
48903 {
48904 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48905 }
48906 {
48907 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48908 }
48909 {
48910 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48911 }
48912 {
48913 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48914 }
48915 {
48916 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48917 }
48918 {
48919 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48920 }
48921 {
48922 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48923 }
48924 {
48925 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48926 }
48927 {
48928 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48929 }
48930 {
48931 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48932 }
48933 {
48934 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48935 }
48936 {
48937 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48938 }
48939 {
48940 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48941 }
48942 {
48943 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48944 }
48945 {
48946 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48947 }
48948 {
48949 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48950 }
48951 {
48952 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48953 }
48954 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48955 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48956 {
48957 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48958 }
48959 {
48960 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48961 }
48962 {
48963 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
48964 }
48965
48966 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
48967
48968
48969 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
48970
48971 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
48972 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
48973 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
48974 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
48975 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
48976 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
48977 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
48978 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
48979 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
48980 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
48981 {
48982 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
48983 }
48984 {
48985 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48986 }
48987 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
48988 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
48989 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
48990 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
48991 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
48992 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
48993 {
48994 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
48995 }
48996 {
48997 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
48998 }
48999 {
49000 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49001 }
49002 {
49003 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49004 }
49005 {
49006 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49007 }
49008 {
49009 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49010 }
49011 {
49012 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49013 }
49014 {
49015 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49016 }
49017 {
49018 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49019 }
49020 {
49021 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49022 }
49023 {
49024 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49025 }
49026 {
49027 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49028 }
49029 {
49030 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49031 }
49032 {
49033 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49034 }
49035 {
49036 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49037 }
49038 {
49039 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49040 }
49041 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49042 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49043 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49044 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49045 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49046 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49047 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49048 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49049 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49050 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49051 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49052 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49053 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49054 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49055 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49056 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49057 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49058 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49059 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49060 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49061 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49062 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49063 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49064 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49065 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49066 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49067 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49068 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49069 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49070 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49071 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49072 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49073 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49074 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49075 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49076 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49077 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49078 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49079 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49080 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49081 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49082 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49083 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49084 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49085 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49086 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49087 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49088 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49089 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49090 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49091 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49092 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49093 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49094 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49095 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49096 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49097 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49098 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49099 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49100 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49101 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49102 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49103 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49104 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49105 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49106 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49107 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49108 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49109 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49110 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49111 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49112 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49113 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49114 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49115 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49116 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49117 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49118 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49119 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49120 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49121 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49122 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49123 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49124 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49125 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49126 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49127 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49128 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49129 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49130 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49131 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49132 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49133 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49134 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49135 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49136 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49137 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49138 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49139 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49140 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49141 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49142 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49143 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49144 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49145 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49146 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49147 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49148 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49149 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49150 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49151 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49152 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49153 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49154 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49155 {
49156 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49157 }
49158 {
49159 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49160 }
49161 {
49162 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49163 }
49164 {
49165 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49166 }
49167 {
49168 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49169 }
49170 {
49171 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49172 }
49173 {
49174 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49175 }
49176 {
49177 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49178 }
49179 {
49180 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49181 }
49182 {
49183 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49184 }
49185 {
49186 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49187 }
49188 {
49189 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49190 }
49191 {
49192 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49193 }
49194 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49195 {
49196 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49212 }
49213 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49214 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49215 {
49216 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49217 }
49218 {
49219 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49220 }
49221 {
49222 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49223 }
49224 {
49225 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49226 }
49227 {
49228 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49229 }
49230 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49231 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49232 {
49233 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49234 }
49235 {
49236 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49237 }
49238 {
49239 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49240 }
49241 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49242 {
49243 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49244 }
49245 {
49246 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49250 }
49251 {
49252 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49253 }
49254 {
49255 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49256 }
49257 {
49258 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49259 }
49260 {
49261 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49262 }
49263 {
49264 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49265 }
49266 {
49267 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49268 }
49269 {
49270 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49271 }
49272 {
49273 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49274 }
49275 {
49276 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49277 }
49278 {
49279 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49280 }
49281 {
49282 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49283 }
49284 {
49285 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49286 }
49287 {
49288 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49289 }
49290 {
49291 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49292 }
49293 {
49294 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49295 }
49296 {
49297 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49298 }
49299
49300 // Initialize threading, some globals and such
49301 __wxPyPreStart(d);
49302
49303
49304 // Although these are defined in __version__ they need to be here too so
49305 // that an assert can be done to ensure that the wxPython and the wxWindows
49306 // versions match.
49307 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49308 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49309 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49310
49311 }
49312
wxWidgets (Impactor)