]> 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
simpler CW setup (needed for 9.5)
[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 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1343 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1344 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1345 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1346 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1347 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1348 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1349 #define SWIGTYPE_p_wxSizer swig_types[7]
1350 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1351 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1352 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1353 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1354 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1355 #define SWIGTYPE_p_wxEvent swig_types[13]
1356 #define SWIGTYPE_p_buffer swig_types[14]
1357 #define SWIGTYPE_p_wxMenu swig_types[15]
1358 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1359 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1360 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1361 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1362 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1363 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1364 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1365 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1366 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1367 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxFont swig_types[27]
1370 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1371 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1372 #define SWIGTYPE_p_wxFSFile swig_types[30]
1373 #define SWIGTYPE_p_wxCaret swig_types[31]
1374 #define SWIGTYPE_ptrdiff_t swig_types[32]
1375 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1376 #define SWIGTYPE_p_wxRegion swig_types[34]
1377 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1378 #define SWIGTYPE_p_int swig_types[36]
1379 #define SWIGTYPE_p_wxSize swig_types[37]
1380 #define SWIGTYPE_p_wxDC swig_types[38]
1381 #define SWIGTYPE_p_wxPySizer swig_types[39]
1382 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1383 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1384 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1385 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1386 #define SWIGTYPE_p_form_ops_t swig_types[44]
1387 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1388 #define SWIGTYPE_p_wxArrayString swig_types[46]
1389 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1390 #define SWIGTYPE_p_wxToolTip swig_types[48]
1391 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1392 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1393 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1394 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1395 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1396 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1397 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1398 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1399 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1400 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1401 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1402 #define SWIGTYPE_p_long swig_types[60]
1403 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1404 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1405 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1406 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1407 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1408 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1409 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1410 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1411 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1412 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1413 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1414 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1415 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1416 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1417 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1418 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1419 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1420 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1421 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1422 #define SWIGTYPE_p_wxRect swig_types[80]
1423 #define SWIGTYPE_p_wxButton swig_types[81]
1424 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1425 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1426 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1427 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1428 #define SWIGTYPE_p_char swig_types[86]
1429 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1430 #define SWIGTYPE_p_wxImage swig_types[88]
1431 #define SWIGTYPE_p_wxFrame swig_types[89]
1432 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1433 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1434 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1435 #define SWIGTYPE_p_wxPoint swig_types[93]
1436 #define SWIGTYPE_p_wxCursor swig_types[94]
1437 #define SWIGTYPE_p_wxObject swig_types[95]
1438 #define SWIGTYPE_p_wxInputStream swig_types[96]
1439 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1440 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1441 #define SWIGTYPE_p_wxDateTime swig_types[99]
1442 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1443 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1444 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1445 #define SWIGTYPE_p_unsigned_long swig_types[103]
1446 #define SWIGTYPE_p_wxWindow swig_types[104]
1447 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1448 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1449 #define SWIGTYPE_p_wxBitmap swig_types[107]
1450 #define SWIGTYPE_unsigned_int swig_types[108]
1451 #define SWIGTYPE_p_unsigned_int swig_types[109]
1452 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1453 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1454 #define SWIGTYPE_p_unsigned_char swig_types[112]
1455 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1456 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1457 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1458 #define SWIGTYPE_p_wxPyApp swig_types[116]
1459 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1460 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1461 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1462 #define SWIGTYPE_p_wxQuantize swig_types[120]
1463 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1464 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1465 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1466 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1467 #define SWIGTYPE_p_wxColour swig_types[125]
1468 #define SWIGTYPE_p_wxValidator swig_types[126]
1469 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1470 static swig_type_info *swig_types[129];
1471
1472 /* -------- TYPES TABLE (END) -------- */
1473
1474
1475 /*-----------------------------------------------
1476 @(target):= _core_.so
1477 ------------------------------------------------*/
1478 #define SWIG_init init_core_
1479
1480 #define SWIG_name "_core_"
1481
1482 #include "wx/wxPython/wxPython_int.h"
1483 #include "wx/wxPython/pyclasses.h"
1484
1485
1486 #ifndef wxPyUSE_EXPORT
1487 // Helper functions for dealing with SWIG objects and such. These are
1488 // located here so they know about the SWIG types and functions declared
1489 // in the wrapper code.
1490
1491 #include <wx/hashmap.h>
1492 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1493
1494
1495 // Maintains a hashmap of className to swig_type_info pointers. Given the
1496 // name of a class either looks up the type info in the cache, or scans the
1497 // SWIG tables for it.
1498 extern PyObject* wxPyPtrTypeMap;
1499 static
1500 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1501
1502 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1503
1504 if (typeInfoCache == NULL)
1505 typeInfoCache = new wxPyTypeInfoHashMap;
1506
1507 wxString name(className);
1508 swig_type_info* swigType = (*typeInfoCache)[name];
1509
1510 if (! swigType) {
1511 // it wasn't in the cache, so look it up from SWIG
1512 name.Append(wxT(" *"));
1513 swigType = SWIG_TypeQuery(name.mb_str());
1514
1515 // if it still wasn't found, try looking for a mapped name
1516 if (!swigType) {
1517 PyObject* item;
1518 name = className;
1519
1520 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1521 (char*)(const char*)name.mbc_str())) != NULL) {
1522 name = wxString(PyString_AsString(item), *wxConvCurrent);
1523 name.Append(wxT(" *"));
1524 swigType = SWIG_TypeQuery(name.mb_str());
1525 }
1526 }
1527 if (swigType) {
1528 // and add it to the map if found
1529 (*typeInfoCache)[className] = swigType;
1530 }
1531 }
1532 return swigType;
1533 }
1534
1535
1536 // Check if a class name is a type known to SWIG
1537 bool wxPyCheckSwigType(const wxChar* className) {
1538
1539 swig_type_info* swigType = wxPyFindSwigType(className);
1540 return swigType != NULL;
1541 }
1542
1543
1544 // Given a pointer to a C++ object and a class name, construct a Python proxy
1545 // object for it.
1546 PyObject* wxPyConstructObject(void* ptr,
1547 const wxChar* className,
1548 int setThisOwn) {
1549
1550 swig_type_info* swigType = wxPyFindSwigType(className);
1551 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1552
1553 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1554 }
1555
1556
1557 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1558 // Ensures that the proxy object is of the specified (or derived) type. If
1559 // not able to perform the conversion then a Python exception is set and the
1560 // error should be handled properly in the caller. Returns True on success.
1561 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1562 const wxChar* className) {
1563
1564 swig_type_info* swigType = wxPyFindSwigType(className);
1565 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1566
1567 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1568 }
1569
1570
1571 // Make a SWIGified pointer object suitable for a .this attribute
1572 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1573
1574 PyObject* robj = NULL;
1575
1576 swig_type_info* swigType = wxPyFindSwigType(className);
1577 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1578
1579 #ifdef SWIG_COBJECT_TYPES
1580 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1581 #else
1582 {
1583 char result[1024];
1584 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1585 PyString_FromString(result) : 0;
1586 }
1587 #endif
1588
1589 return robj;
1590 }
1591
1592
1593
1594
1595 // Export a C API in a struct. Other modules will be able to load this from
1596 // the wx._core_ module and will then have safe access to these functions,
1597 // even if they are located in another shared library.
1598 static wxPyCoreAPI API = {
1599
1600 wxPyCheckSwigType,
1601 wxPyConstructObject,
1602 wxPyConvertSwigPtr,
1603 wxPyMakeSwigPtr,
1604
1605 wxPyBeginAllowThreads,
1606 wxPyEndAllowThreads,
1607 wxPyBeginBlockThreads,
1608 wxPyEndBlockThreads,
1609
1610 wxPy_ConvertList,
1611
1612 wxString_in_helper,
1613 Py2wxString,
1614 wx2PyString,
1615
1616 byte_LIST_helper,
1617 int_LIST_helper,
1618 long_LIST_helper,
1619 string_LIST_helper,
1620 wxPoint_LIST_helper,
1621 wxBitmap_LIST_helper,
1622 wxString_LIST_helper,
1623 wxAcceleratorEntry_LIST_helper,
1624
1625 wxSize_helper,
1626 wxPoint_helper,
1627 wxRealPoint_helper,
1628 wxRect_helper,
1629 wxColour_helper,
1630 wxPoint2D_helper,
1631
1632 wxPySimple_typecheck,
1633 wxColour_typecheck,
1634
1635 wxPyCBH_setCallbackInfo,
1636 wxPyCBH_findCallback,
1637 wxPyCBH_callCallback,
1638 wxPyCBH_callCallbackObj,
1639 wxPyCBH_delete,
1640
1641 wxPyMake_wxObject,
1642 wxPyMake_wxSizer,
1643 wxPyPtrTypeMap_Add,
1644 wxPy2int_seq_helper,
1645 wxPy4int_seq_helper,
1646 wxArrayString2PyList_helper,
1647 wxArrayInt2PyList_helper,
1648
1649 wxPyClientData_dtor,
1650 wxPyUserData_dtor,
1651 wxPyOORClientData_dtor,
1652
1653 wxPyCBInputStream_create,
1654 wxPyCBInputStream_copy,
1655
1656 wxPyInstance_Check,
1657 wxPySwigInstance_Check,
1658
1659 wxPyCheckForApp
1660
1661 };
1662
1663 #endif
1664
1665
1666 #if !WXWIN_COMPATIBILITY_2_4
1667 #define wxHIDE_READONLY 0
1668 #endif
1669
1670
1671 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1672 #define SWIG_From_int PyInt_FromLong
1673 /*@@*/
1674
1675
1676 #if ! wxUSE_HOTKEY
1677 enum wxHotkeyModifier
1678 {
1679 wxMOD_NONE = 0,
1680 wxMOD_ALT = 1,
1681 wxMOD_CONTROL = 2,
1682 wxMOD_SHIFT = 4,
1683 wxMOD_WIN = 8
1684 };
1685 #define wxEVT_HOTKEY 9999
1686 #endif
1687
1688 static const wxString wxPyEmptyString(wxEmptyString);
1689 static wxString wxObject_GetClassName(wxObject *self){
1690 return self->GetClassInfo()->GetClassName();
1691 }
1692 static void wxObject_Destroy(wxObject *self){
1693 delete self;
1694 }
1695
1696 #ifndef __WXMAC__
1697 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1698 #endif
1699
1700
1701 #include <limits.h>
1702
1703
1704 SWIGINTERN int
1705 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1706 const char *errmsg)
1707 {
1708 if (value < min_value) {
1709 if (errmsg) {
1710 PyErr_Format(PyExc_OverflowError,
1711 "value %ld is less than '%s' minimum %ld",
1712 value, errmsg, min_value);
1713 }
1714 return 0;
1715 } else if (value > max_value) {
1716 if (errmsg) {
1717 PyErr_Format(PyExc_OverflowError,
1718 "value %ld is greater than '%s' maximum %ld",
1719 value, errmsg, max_value);
1720 }
1721 return 0;
1722 }
1723 return 1;
1724 }
1725
1726
1727 SWIGINTERN int
1728 SWIG_AsVal_long(PyObject* obj, long* val)
1729 {
1730 if (PyNumber_Check(obj)) {
1731 if (val) *val = PyInt_AsLong(obj);
1732 return 1;
1733 }
1734 else {
1735 SWIG_type_error("number", obj);
1736 }
1737 return 0;
1738 }
1739
1740
1741 #if INT_MAX != LONG_MAX
1742 SWIGINTERN int
1743 SWIG_AsVal_int(PyObject *obj, int *val)
1744 {
1745 const char* errmsg = val ? "int" : (char*)0;
1746 long v;
1747 if (SWIG_AsVal_long(obj, &v)) {
1748 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1749 if (val) *val = (int)(v);
1750 return 1;
1751 } else {
1752 return 0;
1753 }
1754 } else {
1755 PyErr_Clear();
1756 }
1757 if (val) {
1758 SWIG_type_error(errmsg, obj);
1759 }
1760 return 0;
1761 }
1762 #else
1763 SWIGINTERNSHORT int
1764 SWIG_AsVal_int(PyObject *obj, int *val)
1765 {
1766 return SWIG_AsVal_long(obj,(long*)val);
1767 }
1768 #endif
1769
1770
1771 SWIGINTERNSHORT int
1772 SWIG_As_int(PyObject* obj)
1773 {
1774 int v;
1775 if (!SWIG_AsVal_int(obj, &v)) {
1776 /*
1777 this is needed to make valgrind/purify happier.
1778 */
1779 memset((void*)&v, 0, sizeof(int));
1780 }
1781 return v;
1782 }
1783
1784
1785 SWIGINTERNSHORT int
1786 SWIG_Check_int(PyObject* obj)
1787 {
1788 return SWIG_AsVal_int(obj, (int*)0);
1789 }
1790
1791 static PyObject *wxSize_Get(wxSize *self){
1792 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1793 PyObject* tup = PyTuple_New(2);
1794 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1795 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1796 wxPyEndBlockThreads(blocked);
1797 return tup;
1798 }
1799
1800 SWIGINTERN int
1801 SWIG_AsVal_double(PyObject *obj, double* val)
1802 {
1803 if (PyNumber_Check(obj)) {
1804 if (val) *val = PyFloat_AsDouble(obj);
1805 return 1;
1806 }
1807 else {
1808 SWIG_type_error("number", obj);
1809 }
1810 return 0;
1811 }
1812
1813
1814 SWIGINTERNSHORT double
1815 SWIG_As_double(PyObject* obj)
1816 {
1817 double v;
1818 if (!SWIG_AsVal_double(obj, &v)) {
1819 /*
1820 this is needed to make valgrind/purify happier.
1821 */
1822 memset((void*)&v, 0, sizeof(double));
1823 }
1824 return v;
1825 }
1826
1827
1828 SWIGINTERNSHORT int
1829 SWIG_Check_double(PyObject* obj)
1830 {
1831 return SWIG_AsVal_double(obj, (double*)0);
1832 }
1833
1834
1835 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1836 #define SWIG_From_double PyFloat_FromDouble
1837 /*@@*/
1838
1839 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1840 self->x = x;
1841 self->y = y;
1842 }
1843 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1844 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1845 PyObject* tup = PyTuple_New(2);
1846 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1847 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1848 wxPyEndBlockThreads(blocked);
1849 return tup;
1850 }
1851
1852 SWIGINTERNSHORT long
1853 SWIG_As_long(PyObject* obj)
1854 {
1855 long v;
1856 if (!SWIG_AsVal_long(obj, &v)) {
1857 /*
1858 this is needed to make valgrind/purify happier.
1859 */
1860 memset((void*)&v, 0, sizeof(long));
1861 }
1862 return v;
1863 }
1864
1865
1866 SWIGINTERNSHORT int
1867 SWIG_Check_long(PyObject* obj)
1868 {
1869 return SWIG_AsVal_long(obj, (long*)0);
1870 }
1871
1872 static void wxPoint_Set(wxPoint *self,long x,long y){
1873 self->x = x;
1874 self->y = y;
1875 }
1876 static PyObject *wxPoint_Get(wxPoint *self){
1877 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1878 PyObject* tup = PyTuple_New(2);
1879 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1880 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1881 wxPyEndBlockThreads(blocked);
1882 return tup;
1883 }
1884 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1885 self->x = x;
1886 self->y = y;
1887 self->width = width;
1888 self->height = height;
1889 }
1890 static PyObject *wxRect_Get(wxRect *self){
1891 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1892 PyObject* tup = PyTuple_New(4);
1893 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1894 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1895 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1896 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1897 wxPyEndBlockThreads(blocked);
1898 return tup;
1899 }
1900
1901 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1902 wxRegion reg1(*r1);
1903 wxRegion reg2(*r2);
1904 wxRect dest(0,0,0,0);
1905 PyObject* obj;
1906
1907 reg1.Intersect(reg2);
1908 dest = reg1.GetBox();
1909
1910 if (dest != wxRect(0,0,0,0)) {
1911 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1912 wxRect* newRect = new wxRect(dest);
1913 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1914 wxPyEndBlockThreads(blocked);
1915 return obj;
1916 }
1917 Py_INCREF(Py_None);
1918 return Py_None;
1919 }
1920
1921
1922 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1923 PyObject* o2;
1924 PyObject* o3;
1925
1926 if (!target) {
1927 target = o;
1928 } else if (target == Py_None) {
1929 Py_DECREF(Py_None);
1930 target = o;
1931 } else {
1932 if (!PyTuple_Check(target)) {
1933 o2 = target;
1934 target = PyTuple_New(1);
1935 PyTuple_SetItem(target, 0, o2);
1936 }
1937 o3 = PyTuple_New(1);
1938 PyTuple_SetItem(o3, 0, o);
1939
1940 o2 = target;
1941 target = PySequence_Concat(o2, o3);
1942 Py_DECREF(o2);
1943 Py_DECREF(o3);
1944 }
1945 return target;
1946 }
1947
1948
1949 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1950 self->m_x = x;
1951 self->m_y = y;
1952 }
1953 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1954 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1955 PyObject* tup = PyTuple_New(2);
1956 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1957 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1958 wxPyEndBlockThreads(blocked);
1959 return tup;
1960 }
1961
1962 #include "wx/wxPython/pyistream.h"
1963
1964 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1965 wxInputStream* wxis = wxPyCBInputStream::create(p);
1966 if (wxis)
1967 return new wxPyInputStream(wxis);
1968 else
1969 return NULL;
1970 }
1971
1972 SWIGINTERNSHORT PyObject*
1973 SWIG_From_char(char c)
1974 {
1975 return PyString_FromStringAndSize(&c,1);
1976 }
1977
1978
1979 SWIGINTERNSHORT PyObject*
1980 SWIG_From_unsigned_SS_long(unsigned long value)
1981 {
1982 return (value > LONG_MAX) ?
1983 PyLong_FromUnsignedLong(value)
1984 : PyInt_FromLong((long)(value));
1985 }
1986
1987
1988 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1989 SWIGINTERN int
1990 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1991 {
1992 static swig_type_info* pchar_info = 0;
1993 char* vptr = 0;
1994 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1995 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1996 if (cptr) *cptr = vptr;
1997 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1998 return SWIG_OLDOBJ;
1999 } else {
2000 PyErr_Clear();
2001 if (PyString_Check(obj)) {
2002 if (cptr) {
2003 *cptr = PyString_AS_STRING(obj);
2004 if (psize) {
2005 *psize = PyString_GET_SIZE(obj) + 1;
2006 }
2007 }
2008 return SWIG_PYSTR;
2009 }
2010 }
2011 if (cptr) {
2012 SWIG_type_error("char *", obj);
2013 }
2014 return 0;
2015 }
2016
2017
2018 SWIGINTERN int
2019 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2020 {
2021 char* cptr; size_t csize;
2022 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2023 /* in C you can do:
2024
2025 char x[5] = "hello";
2026
2027 ie, assing the array using an extra '0' char.
2028 */
2029 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2030 if (csize <= size) {
2031 if (val) {
2032 if (csize) memcpy(val, cptr, csize);
2033 if (csize < size) memset(val + csize, 0, size - csize);
2034 }
2035 return 1;
2036 }
2037 }
2038 if (val) {
2039 PyErr_Format(PyExc_TypeError,
2040 "a char array of maximum size %lu is expected",
2041 (unsigned long) size);
2042 }
2043 return 0;
2044 }
2045
2046
2047 SWIGINTERN int
2048 SWIG_AsVal_char(PyObject *obj, char *val)
2049 {
2050 const char* errmsg = val ? "char" : (char*)0;
2051 long v;
2052 if (SWIG_AsVal_long(obj, &v)) {
2053 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2054 if (val) *val = (char)(v);
2055 return 1;
2056 } else {
2057 return 0;
2058 }
2059 } else {
2060 PyErr_Clear();
2061 return SWIG_AsCharArray(obj, val, 1);
2062 }
2063 }
2064
2065
2066 SWIGINTERNSHORT char
2067 SWIG_As_char(PyObject* obj)
2068 {
2069 char v;
2070 if (!SWIG_AsVal_char(obj, &v)) {
2071 /*
2072 this is needed to make valgrind/purify happier.
2073 */
2074 memset((void*)&v, 0, sizeof(char));
2075 }
2076 return v;
2077 }
2078
2079
2080 SWIGINTERNSHORT int
2081 SWIG_Check_char(PyObject* obj)
2082 {
2083 return SWIG_AsVal_char(obj, (char*)0);
2084 }
2085
2086
2087 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2088 #define SWIG_From_long PyInt_FromLong
2089 /*@@*/
2090
2091 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2092 // We use only strings for the streams, not unicode
2093 PyObject* str = PyObject_Str(obj);
2094 if (! str) {
2095 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2096 return;
2097 }
2098 self->Write(PyString_AS_STRING(str),
2099 PyString_GET_SIZE(str));
2100 Py_DECREF(str);
2101 }
2102
2103 #include "wx/wxPython/pyistream.h"
2104
2105
2106 class wxPyFileSystemHandler : public wxFileSystemHandler
2107 {
2108 public:
2109 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2110
2111 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2112 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2113 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2114 DEC_PYCALLBACK_STRING__pure(FindNext);
2115
2116 wxString GetProtocol(const wxString& location) {
2117 return wxFileSystemHandler::GetProtocol(location);
2118 }
2119
2120 wxString GetLeftLocation(const wxString& location) {
2121 return wxFileSystemHandler::GetLeftLocation(location);
2122 }
2123
2124 wxString GetAnchor(const wxString& location) {
2125 return wxFileSystemHandler::GetAnchor(location);
2126 }
2127
2128 wxString GetRightLocation(const wxString& location) {
2129 return wxFileSystemHandler::GetRightLocation(location);
2130 }
2131
2132 wxString GetMimeTypeFromExt(const wxString& location) {
2133 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2134 }
2135
2136 PYPRIVATE;
2137 };
2138
2139
2140 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2141 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2142 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2143 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2144
2145
2146 SWIGINTERN int
2147 SWIG_AsVal_bool(PyObject *obj, bool *val)
2148 {
2149 if (obj == Py_True) {
2150 if (val) *val = true;
2151 return 1;
2152 }
2153 if (obj == Py_False) {
2154 if (val) *val = false;
2155 return 1;
2156 }
2157 int res = 0;
2158 if (SWIG_AsVal_int(obj, &res)) {
2159 if (val) *val = res ? true : false;
2160 return 1;
2161 } else {
2162 PyErr_Clear();
2163 }
2164 if (val) {
2165 SWIG_type_error("bool", obj);
2166 }
2167 return 0;
2168 }
2169
2170
2171 SWIGINTERNSHORT bool
2172 SWIG_As_bool(PyObject* obj)
2173 {
2174 bool v;
2175 if (!SWIG_AsVal_bool(obj, &v)) {
2176 /*
2177 this is needed to make valgrind/purify happier.
2178 */
2179 memset((void*)&v, 0, sizeof(bool));
2180 }
2181 return v;
2182 }
2183
2184
2185 SWIGINTERNSHORT int
2186 SWIG_Check_bool(PyObject* obj)
2187 {
2188 return SWIG_AsVal_bool(obj, (bool*)0);
2189 }
2190
2191 static wxString FileSystem_URLToFileName(wxString const &url){
2192 wxFileName fname = wxFileSystem::URLToFileName(url);
2193 return fname.GetFullPath();
2194 }
2195
2196 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2197 wxImage& image,
2198 long type) {
2199 wxMemoryFSHandler::AddFile(filename, image, type);
2200 }
2201
2202 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2203 const wxBitmap& bitmap,
2204 long type) {
2205 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2206 }
2207
2208 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2209 PyObject* data) {
2210 if (! PyString_Check(data)) {
2211 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2212 "Expected string object"));
2213 return;
2214 }
2215
2216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2217 void* ptr = (void*)PyString_AsString(data);
2218 size_t size = PyString_Size(data);
2219 wxPyEndBlockThreads(blocked);
2220
2221 wxMemoryFSHandler::AddFile(filename, ptr, size);
2222 }
2223
2224
2225 #include "wx/wxPython/pyistream.h"
2226
2227
2228 SWIGINTERN int
2229 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2230 {
2231 long v = 0;
2232 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2233 SWIG_type_error("unsigned number", obj);
2234 }
2235 else if (val)
2236 *val = (unsigned long)v;
2237 return 1;
2238 }
2239
2240
2241 SWIGINTERNSHORT int
2242 SWIG_CheckUnsignedLongInRange(unsigned long value,
2243 unsigned long max_value,
2244 const char *errmsg)
2245 {
2246 if (value > max_value) {
2247 if (errmsg) {
2248 PyErr_Format(PyExc_OverflowError,
2249 "value %lu is greater than '%s' minimum %lu",
2250 value, errmsg, max_value);
2251 }
2252 return 0;
2253 }
2254 return 1;
2255 }
2256
2257
2258 SWIGINTERN int
2259 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2260 {
2261 const char* errmsg = val ? "unsigned char" : (char*)0;
2262 unsigned long v;
2263 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2264 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2265 if (val) *val = (unsigned char)(v);
2266 return 1;
2267 } else {
2268 return 0;
2269 }
2270 } else {
2271 PyErr_Clear();
2272 }
2273 if (val) {
2274 SWIG_type_error(errmsg, obj);
2275 }
2276 return 0;
2277 }
2278
2279
2280 SWIGINTERNSHORT unsigned char
2281 SWIG_As_unsigned_SS_char(PyObject* obj)
2282 {
2283 unsigned char v;
2284 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2285 /*
2286 this is needed to make valgrind/purify happier.
2287 */
2288 memset((void*)&v, 0, sizeof(unsigned char));
2289 }
2290 return v;
2291 }
2292
2293
2294 SWIGINTERNSHORT int
2295 SWIG_Check_unsigned_SS_char(PyObject* obj)
2296 {
2297 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2298 }
2299
2300
2301 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2302 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2303 /*@@*/
2304
2305
2306
2307 SWIGINTERNSHORT unsigned long
2308 SWIG_As_unsigned_SS_long(PyObject* obj)
2309 {
2310 unsigned long v;
2311 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2312 /*
2313 this is needed to make valgrind/purify happier.
2314 */
2315 memset((void*)&v, 0, sizeof(unsigned long));
2316 }
2317 return v;
2318 }
2319
2320
2321 SWIGINTERNSHORT int
2322 SWIG_Check_unsigned_SS_long(PyObject* obj)
2323 {
2324 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2325 }
2326
2327 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2328 wxImageHistogramEntry e = (*self)[key];
2329 return e.value;
2330 }
2331 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2332 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2333 wxImageHistogramEntry e = (*self)[key];
2334 return e.value;
2335 }
2336 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2337 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2338 colour.Green(),
2339 colour.Blue());
2340 wxImageHistogramEntry e = (*self)[key];
2341 return e.value;
2342 }
2343
2344 typedef unsigned char* buffer;
2345
2346 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2347 if (width > 0 && height > 0)
2348 return new wxImage(width, height, clear);
2349 else
2350 return new wxImage;
2351 }
2352 static wxImage *new_wxImage(wxBitmap const &bitmap){
2353 return new wxImage(bitmap.ConvertToImage());
2354 }
2355 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2356 if (DATASIZE != width*height*3) {
2357 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2358 return NULL;
2359 }
2360
2361 // Copy the source data so the wxImage can clean it up later
2362 buffer copy = (buffer)malloc(DATASIZE);
2363 if (copy == NULL) {
2364 wxPyBLOCK_THREADS(PyErr_NoMemory());
2365 return NULL;
2366 }
2367 memcpy(copy, data, DATASIZE);
2368 return new wxImage(width, height, copy, false);
2369 }
2370 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2371 if (DATASIZE != width*height*3) {
2372 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2373 return NULL;
2374 }
2375 if (ALPHASIZE != width*height) {
2376 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2377 return NULL;
2378 }
2379
2380 // Copy the source data so the wxImage can clean it up later
2381 buffer dcopy = (buffer)malloc(DATASIZE);
2382 if (dcopy == NULL) {
2383 wxPyBLOCK_THREADS(PyErr_NoMemory());
2384 return NULL;
2385 }
2386 memcpy(dcopy, data, DATASIZE);
2387
2388 buffer acopy = (buffer)malloc(ALPHASIZE);
2389 if (acopy == NULL) {
2390 wxPyBLOCK_THREADS(PyErr_NoMemory());
2391 return NULL;
2392 }
2393 memcpy(acopy, alpha, ALPHASIZE);
2394
2395 return new wxImage(width, height, dcopy, acopy, false);
2396 }
2397 static wxSize wxImage_GetSize(wxImage *self){
2398 wxSize size(self->GetWidth(), self->GetHeight());
2399 return size;
2400 }
2401 static PyObject *wxImage_GetData(wxImage *self){
2402 buffer data = self->GetData();
2403 int len = self->GetWidth() * self->GetHeight() * 3;
2404 PyObject* rv;
2405 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2406 return rv;
2407 }
2408 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2409 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2410 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2411 return;
2412 }
2413 buffer copy = (buffer)malloc(DATASIZE);
2414 if (copy == NULL) {
2415 wxPyBLOCK_THREADS(PyErr_NoMemory());
2416 return;
2417 }
2418 memcpy(copy, data, DATASIZE);
2419 self->SetData(copy, false);
2420 // wxImage takes ownership of copy...
2421 }
2422 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2423 buffer data = self->GetData();
2424 int len = self->GetWidth() * self->GetHeight() * 3;
2425 PyObject* rv;
2426 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2427 return rv;
2428 }
2429 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2430 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2431 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2432 return;
2433 }
2434 self->SetData(data, true);
2435 }
2436 static PyObject *wxImage_GetAlphaData(wxImage *self){
2437 buffer data = self->GetAlpha();
2438 if (! data) {
2439 RETURN_NONE();
2440 } else {
2441 int len = self->GetWidth() * self->GetHeight();
2442 PyObject* rv;
2443 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2444 return rv;
2445 }
2446 }
2447 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2448 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2449 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2450 return;
2451 }
2452 buffer acopy = (buffer)malloc(ALPHASIZE);
2453 if (acopy == NULL) {
2454 wxPyBLOCK_THREADS(PyErr_NoMemory());
2455 return;
2456 }
2457 memcpy(acopy, alpha, ALPHASIZE);
2458 self->SetAlpha(acopy, false);
2459 // wxImage takes ownership of acopy...
2460 }
2461 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2462 buffer data = self->GetAlpha();
2463 int len = self->GetWidth() * self->GetHeight();
2464 PyObject* rv;
2465 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2466 return rv;
2467 }
2468 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2469 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2470 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2471 return;
2472 }
2473 self->SetAlpha(alpha, true);
2474 }
2475 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2476 wxBitmap bitmap(*self, depth);
2477 return bitmap;
2478 }
2479 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2480 wxImage mono = self->ConvertToMono( red, green, blue );
2481 wxBitmap bitmap( mono, 1 );
2482 return bitmap;
2483 }
2484 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2485 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2487 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2491 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2492 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2493 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2494 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2495 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2496 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2497 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2498 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2499
2500 #include <wx/quantize.h>
2501
2502 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2503 return wxQuantize::Quantize(src, dest,
2504 //NULL, // palette
2505 desiredNoColours,
2506 NULL, // eightBitData
2507 flags);
2508 }
2509 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2510 if (PyCallable_Check(func)) {
2511 self->Connect(id, lastId, eventType,
2512 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2513 new wxPyCallback(func));
2514 }
2515 else if (func == Py_None) {
2516 self->Disconnect(id, lastId, eventType,
2517 (wxObjectEventFunction)
2518 &wxPyCallback::EventThunker);
2519 }
2520 else {
2521 wxPyBLOCK_THREADS(
2522 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2523 }
2524 }
2525 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2526 return self->Disconnect(id, lastId, eventType,
2527 (wxObjectEventFunction)
2528 &wxPyCallback::EventThunker);
2529 }
2530 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2531 if (_self && _self != Py_None) {
2532 self->SetClientObject(new wxPyOORClientData(_self, incref));
2533 }
2534 else {
2535 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2536 if (data) {
2537 self->SetClientObject(NULL); // This will delete it too
2538 }
2539 }
2540 }
2541
2542 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2543 #if wxUSE_UNICODE
2544 return self->GetUnicodeKey();
2545 #else
2546 return 0;
2547 #endif
2548 }
2549
2550 #if UINT_MAX < LONG_MAX
2551 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2552 #define SWIG_From_unsigned_SS_int SWIG_From_long
2553 /*@@*/
2554 #else
2555 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2556 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2557 /*@@*/
2558 #endif
2559
2560
2561 #if UINT_MAX != ULONG_MAX
2562 SWIGINTERN int
2563 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2564 {
2565 const char* errmsg = val ? "unsigned int" : (char*)0;
2566 unsigned long v;
2567 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2568 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2569 if (val) *val = (unsigned int)(v);
2570 return 1;
2571 }
2572 } else {
2573 PyErr_Clear();
2574 }
2575 if (val) {
2576 SWIG_type_error(errmsg, obj);
2577 }
2578 return 0;
2579 }
2580 #else
2581 SWIGINTERNSHORT unsigned int
2582 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2583 {
2584 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2585 }
2586 #endif
2587
2588
2589 SWIGINTERNSHORT unsigned int
2590 SWIG_As_unsigned_SS_int(PyObject* obj)
2591 {
2592 unsigned int v;
2593 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2594 /*
2595 this is needed to make valgrind/purify happier.
2596 */
2597 memset((void*)&v, 0, sizeof(unsigned int));
2598 }
2599 return v;
2600 }
2601
2602
2603 SWIGINTERNSHORT int
2604 SWIG_Check_unsigned_SS_int(PyObject* obj)
2605 {
2606 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2607 }
2608
2609 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2610 self->m_size = size;
2611 }
2612 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2613 int count = self->GetNumberOfFiles();
2614 wxString* files = self->GetFiles();
2615 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2616 PyObject* list = PyList_New(count);
2617
2618 if (!list) {
2619 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2620 wxPyEndBlockThreads(blocked);
2621 return NULL;
2622 }
2623
2624 for (int i=0; i<count; i++) {
2625 PyList_SetItem(list, i, wx2PyString(files[i]));
2626 }
2627 wxPyEndBlockThreads(blocked);
2628 return list;
2629 }
2630
2631
2632 static wxPyApp *new_wxPyApp(){
2633 wxPythonApp = new wxPyApp();
2634 return wxPythonApp;
2635 }
2636 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2637
2638 void wxApp_CleanUp() {
2639 __wxPyCleanup();
2640 }
2641
2642
2643 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2644
2645
2646 SWIGINTERNSHORT int
2647 SWIG_AsCharPtr(PyObject *obj, char **val)
2648 {
2649 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2650 return 1;
2651 }
2652 if (val) {
2653 PyErr_Clear();
2654 SWIG_type_error("char *", obj);
2655 }
2656 return 0;
2657 }
2658
2659
2660 SWIGINTERN PyObject *
2661 SWIG_FromCharPtr(const char* cptr)
2662 {
2663 if (cptr) {
2664 size_t size = strlen(cptr);
2665 if (size > INT_MAX) {
2666 return SWIG_NewPointerObj((char*)(cptr),
2667 SWIG_TypeQuery("char *"), 0);
2668 } else {
2669 if (size != 0) {
2670 return PyString_FromStringAndSize(cptr, size);
2671 } else {
2672 return PyString_FromString(cptr);
2673 }
2674 }
2675 }
2676 Py_INCREF(Py_None);
2677 return Py_None;
2678 }
2679
2680
2681 #ifdef __WXMAC__
2682
2683 // A dummy class that raises an exception if used...
2684 class wxEventLoop
2685 {
2686 public:
2687 wxEventLoop() { wxPyRaiseNotImplemented(); }
2688 int Run() { return 0; }
2689 void Exit(int rc = 0) {}
2690 bool Pending() const { return false; }
2691 bool Dispatch() { return false; }
2692 bool IsRunning() const { return false; }
2693 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2694 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2695 };
2696
2697 #else
2698
2699 #include <wx/evtloop.h>
2700
2701 #endif
2702
2703
2704
2705 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2706 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2707 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2708 static PyObject *wxWindow_GetChildren(wxWindow *self){
2709 wxWindowList& list = self->GetChildren();
2710 return wxPy_ConvertList(&list);
2711 }
2712 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2713 #if wxUSE_HOTKEY
2714 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2715 #else
2716 return false;
2717 #endif
2718 }
2719 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2720
2721
2722
2723 return false;
2724
2725 }
2726 static long wxWindow_GetHandle(wxWindow *self){
2727 return wxPyGetWinHandle(self);
2728 }
2729 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2730 self->AssociateHandle((WXWidget)handle);
2731 }
2732 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
2733
2734 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2735 return wxWindow::FindWindowById(id, parent);
2736 }
2737
2738 wxWindow* wxFindWindowByName( const wxString& name,
2739 const wxWindow *parent = NULL ) {
2740 return wxWindow::FindWindowByName(name, parent);
2741 }
2742
2743 wxWindow* wxFindWindowByLabel( const wxString& label,
2744 const wxWindow *parent = NULL ) {
2745 return wxWindow::FindWindowByLabel(label, parent);
2746 }
2747
2748
2749 #ifdef __WXMSW__
2750 #include <wx/msw/private.h> // to get wxGetWindowId
2751 #endif
2752
2753
2754 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2755 #ifdef __WXMSW__
2756 WXHWND hWnd = (WXHWND)_hWnd;
2757 long id = wxGetWindowId(hWnd);
2758 wxWindow* win = new wxWindow;
2759 parent->AddChild(win);
2760 win->SetEventHandler(win);
2761 win->SetHWND(hWnd);
2762 win->SetId(id);
2763 win->SubclassWin(hWnd);
2764 win->AdoptAttributesFromHWND();
2765 win->SetupColours();
2766 return win;
2767 #else
2768 wxPyRaiseNotImplemented();
2769 return NULL;
2770 #endif
2771 }
2772
2773
2774 PyObject* GetTopLevelWindows() {
2775 return wxPy_ConvertList(&wxTopLevelWindows);
2776 }
2777
2778
2779 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2780 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2781 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2782
2783 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2784
2785 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2786 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2787 wxMenuItemList& list = self->GetMenuItems();
2788 return wxPy_ConvertList(&list);
2789 }
2790 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2791 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2792 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2793 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2794 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2795 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2796 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2797 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2798 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2799 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2800 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2801 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2802 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2803 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2804 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2805 static const wxString wxPyControlNameStr(wxControlNameStr);
2806 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2807 if (clientData) {
2808 wxPyClientData* data = new wxPyClientData(clientData);
2809 return self->Append(item, data);
2810 } else
2811 return self->Append(item);
2812 }
2813 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2814 if (clientData) {
2815 wxPyClientData* data = new wxPyClientData(clientData);
2816 return self->Insert(item, pos, data);
2817 } else
2818 return self->Insert(item, pos);
2819 }
2820 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2821 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2822 if (data) {
2823 Py_INCREF(data->m_obj);
2824 return data->m_obj;
2825 } else {
2826 Py_INCREF(Py_None);
2827 return Py_None;
2828 }
2829 }
2830 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2831 wxPyClientData* data = new wxPyClientData(clientData);
2832 self->SetClientObject(n, data);
2833 }
2834
2835
2836 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2837 wxPyUserData* data = NULL;
2838 if ( userData ) {
2839 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2840 data = new wxPyUserData(userData);
2841 wxPyEndBlockThreads(blocked);
2842 }
2843 return new wxSizerItem(window, proportion, flag, border, data);
2844 }
2845 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2846 wxPyUserData* data = NULL;
2847 if ( userData ) {
2848 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2849 data = new wxPyUserData(userData);
2850 wxPyEndBlockThreads(blocked);
2851 }
2852 return new wxSizerItem(width, height, proportion, flag, border, data);
2853 }
2854 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2855 wxPyUserData* data = NULL;
2856 if ( userData ) {
2857 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2858 data = new wxPyUserData(userData);
2859 wxPyEndBlockThreads(blocked);
2860 }
2861 return new wxSizerItem(sizer, proportion, flag, border, data);
2862 }
2863
2864 #include <float.h>
2865 SWIGINTERN int
2866 SWIG_CheckDoubleInRange(double value, double min_value,
2867 double max_value, const char* errmsg)
2868 {
2869 if (value < min_value) {
2870 if (errmsg) {
2871 PyErr_Format(PyExc_OverflowError,
2872 "value %g is less than %s minimum %g",
2873 value, errmsg, min_value);
2874 }
2875 return 0;
2876 } else if (value > max_value) {
2877 if (errmsg) {
2878 PyErr_Format(PyExc_OverflowError,
2879 "value %g is greater than %s maximum %g",
2880 value, errmsg, max_value);
2881 }
2882 return 0;
2883 }
2884 return 1;
2885 }
2886
2887
2888 SWIGINTERN int
2889 SWIG_AsVal_float(PyObject *obj, float *val)
2890 {
2891 const char* errmsg = val ? "float" : (char*)0;
2892 double v;
2893 if (SWIG_AsVal_double(obj, &v)) {
2894 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2895 if (val) *val = (float)(v);
2896 return 1;
2897 } else {
2898 return 0;
2899 }
2900 } else {
2901 PyErr_Clear();
2902 }
2903 if (val) {
2904 SWIG_type_error(errmsg, obj);
2905 }
2906 return 0;
2907 }
2908
2909
2910 SWIGINTERNSHORT float
2911 SWIG_As_float(PyObject* obj)
2912 {
2913 float v;
2914 if (!SWIG_AsVal_float(obj, &v)) {
2915 /*
2916 this is needed to make valgrind/purify happier.
2917 */
2918 memset((void*)&v, 0, sizeof(float));
2919 }
2920 return v;
2921 }
2922
2923
2924 SWIGINTERNSHORT int
2925 SWIG_Check_float(PyObject* obj)
2926 {
2927 return SWIG_AsVal_float(obj, (float*)0);
2928 }
2929
2930
2931 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2932 #define SWIG_From_float PyFloat_FromDouble
2933 /*@@*/
2934
2935 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2936 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2937 if (data) {
2938 Py_INCREF(data->m_obj);
2939 return data->m_obj;
2940 } else {
2941 Py_INCREF(Py_None);
2942 return Py_None;
2943 }
2944 }
2945
2946 // Figure out the type of the sizer item
2947
2948 struct wxPySizerItemInfo {
2949 wxPySizerItemInfo()
2950 : window(NULL), sizer(NULL), gotSize(false),
2951 size(wxDefaultSize), gotPos(false), pos(-1)
2952 {}
2953
2954 wxWindow* window;
2955 wxSizer* sizer;
2956 bool gotSize;
2957 wxSize size;
2958 bool gotPos;
2959 int pos;
2960 };
2961
2962 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2963
2964 wxPySizerItemInfo info;
2965 wxSize size;
2966 wxSize* sizePtr = &size;
2967
2968 // Find out what the type of the item is
2969 // try wxWindow
2970 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2971 PyErr_Clear();
2972 info.window = NULL;
2973
2974 // try wxSizer
2975 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2976 PyErr_Clear();
2977 info.sizer = NULL;
2978
2979 // try wxSize or (w,h)
2980 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2981 info.size = *sizePtr;
2982 info.gotSize = true;
2983 }
2984
2985 // or a single int
2986 if (checkIdx && PyInt_Check(item)) {
2987 info.pos = PyInt_AsLong(item);
2988 info.gotPos = true;
2989 }
2990 }
2991 }
2992
2993 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2994 // no expected type, figure out what kind of error message to generate
2995 if ( !checkSize && !checkIdx )
2996 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2997 else if ( checkSize && !checkIdx )
2998 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2999 else if ( !checkSize && checkIdx)
3000 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
3001 else
3002 // can this one happen?
3003 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
3004 }
3005
3006 return info;
3007 }
3008
3009 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3010 if (!self->GetClientObject())
3011 self->SetClientObject(new wxPyOORClientData(_self));
3012 }
3013 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3014
3015 wxPyUserData* data = NULL;
3016 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3017 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3018 if ( userData && (info.window || info.sizer || info.gotSize) )
3019 data = new wxPyUserData(userData);
3020 wxPyEndBlockThreads(blocked);
3021
3022 // Now call the real Add method if a valid item type was found
3023 if ( info.window )
3024 return self->Add(info.window, proportion, flag, border, data);
3025 else if ( info.sizer )
3026 return self->Add(info.sizer, proportion, flag, border, data);
3027 else if (info.gotSize)
3028 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3029 proportion, flag, border, data);
3030 else
3031 return NULL;
3032 }
3033 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3034
3035 wxPyUserData* data = NULL;
3036 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3037 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3038 if ( userData && (info.window || info.sizer || info.gotSize) )
3039 data = new wxPyUserData(userData);
3040 wxPyEndBlockThreads(blocked);
3041
3042 // Now call the real Insert method if a valid item type was found
3043 if ( info.window )
3044 return self->Insert(before, info.window, proportion, flag, border, data);
3045 else if ( info.sizer )
3046 return self->Insert(before, info.sizer, proportion, flag, border, data);
3047 else if (info.gotSize)
3048 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3049 proportion, flag, border, data);
3050 else
3051 return NULL;
3052 }
3053 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3054
3055 wxPyUserData* data = NULL;
3056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3057 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3058 if ( userData && (info.window || info.sizer || info.gotSize) )
3059 data = new wxPyUserData(userData);
3060 wxPyEndBlockThreads(blocked);
3061
3062 // Now call the real Prepend method if a valid item type was found
3063 if ( info.window )
3064 return self->Prepend(info.window, proportion, flag, border, data);
3065 else if ( info.sizer )
3066 return self->Prepend(info.sizer, proportion, flag, border, data);
3067 else if (info.gotSize)
3068 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3069 proportion, flag, border, data);
3070 else
3071 return NULL;
3072 }
3073 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3074 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3075 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3076 wxPyEndBlockThreads(blocked);
3077 if ( info.window )
3078 return self->Remove(info.window);
3079 else if ( info.sizer )
3080 return self->Remove(info.sizer);
3081 else if ( info.gotPos )
3082 return self->Remove(info.pos);
3083 else
3084 return false;
3085 }
3086 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3087 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3088 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3089 wxPyEndBlockThreads(blocked);
3090 if ( info.window )
3091 return self->Detach(info.window);
3092 else if ( info.sizer )
3093 return self->Detach(info.sizer);
3094 else if ( info.gotPos )
3095 return self->Detach(info.pos);
3096 else
3097 return false;
3098 }
3099 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3100 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3101 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3102 wxPyEndBlockThreads(blocked);
3103 if ( info.window )
3104 return self->GetItem(info.window);
3105 else if ( info.sizer )
3106 return self->GetItem(info.sizer);
3107 else if ( info.gotPos )
3108 return self->GetItem(info.pos);
3109 else
3110 return NULL;
3111 }
3112 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3113 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3114 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3115 wxPyEndBlockThreads(blocked);
3116 if ( info.window )
3117 self->SetItemMinSize(info.window, size);
3118 else if ( info.sizer )
3119 self->SetItemMinSize(info.sizer, size);
3120 else if ( info.gotPos )
3121 self->SetItemMinSize(info.pos, size);
3122 }
3123 static PyObject *wxSizer_GetChildren(wxSizer *self){
3124 wxSizerItemList& list = self->GetChildren();
3125 return wxPy_ConvertList(&list);
3126 }
3127 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3130 wxPyEndBlockThreads(blocked);
3131 if ( info.window )
3132 return self->Show(info.window, show, recursive);
3133 else if ( info.sizer )
3134 return self->Show(info.sizer, show, recursive);
3135 else if ( info.gotPos )
3136 return self->Show(info.pos, show);
3137 else
3138 return false;
3139 }
3140 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3142 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3143 wxPyEndBlockThreads(blocked);
3144 if ( info.window )
3145 return self->IsShown(info.window);
3146 else if ( info.sizer )
3147 return self->IsShown(info.sizer);
3148 else if ( info.gotPos )
3149 return self->IsShown(info.pos);
3150 else
3151 return false;
3152 }
3153
3154 // See pyclasses.h
3155 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3156 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3157 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3158
3159
3160
3161
3162 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3163 {
3164 if (source == Py_None) {
3165 **obj = wxGBPosition(-1,-1);
3166 return true;
3167 }
3168 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3169 }
3170
3171 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3172 {
3173 if (source == Py_None) {
3174 **obj = wxGBSpan(-1,-1);
3175 return true;
3176 }
3177 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3178 }
3179
3180
3181 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3182 self->SetRow(row);
3183 self->SetCol(col);
3184 }
3185 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3187 PyObject* tup = PyTuple_New(2);
3188 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3189 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3190 wxPyEndBlockThreads(blocked);
3191 return tup;
3192 }
3193 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3194 self->SetRowspan(rowspan);
3195 self->SetColspan(colspan);
3196 }
3197 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3199 PyObject* tup = PyTuple_New(2);
3200 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3201 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3202 wxPyEndBlockThreads(blocked);
3203 return tup;
3204 }
3205 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3206 wxPyUserData* data = NULL;
3207 if ( userData ) {
3208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3209 data = new wxPyUserData(userData);
3210 wxPyEndBlockThreads(blocked);
3211 }
3212 return new wxGBSizerItem(window, pos, span, flag, border, data);
3213 }
3214 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3215 wxPyUserData* data = NULL;
3216 if ( userData ) {
3217 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3218 data = new wxPyUserData(userData);
3219 wxPyEndBlockThreads(blocked);
3220 }
3221 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3222 }
3223 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3224 wxPyUserData* data = NULL;
3225 if ( userData ) {
3226 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3227 data = new wxPyUserData(userData);
3228 wxPyEndBlockThreads(blocked);
3229 }
3230 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3231 }
3232 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3233 int row, col;
3234 self->GetEndPos(row, col);
3235 return wxGBPosition(row, col);
3236 }
3237 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3238
3239 wxPyUserData* data = NULL;
3240 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3241 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3242 if ( userData && (info.window || info.sizer || info.gotSize) )
3243 data = new wxPyUserData(userData);
3244 wxPyEndBlockThreads(blocked);
3245
3246 // Now call the real Add method if a valid item type was found
3247 if ( info.window )
3248 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3249 else if ( info.sizer )
3250 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3251 else if (info.gotSize)
3252 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3253 pos, span, flag, border, data);
3254 return NULL;
3255 }
3256
3257
3258 #ifdef __cplusplus
3259 extern "C" {
3260 #endif
3261 static int _wrap_EmptyString_set(PyObject *) {
3262 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3263 return 1;
3264 }
3265
3266
3267 static PyObject *_wrap_EmptyString_get(void) {
3268 PyObject *pyobj;
3269
3270 {
3271 #if wxUSE_UNICODE
3272 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3273 #else
3274 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3275 #endif
3276 }
3277 return pyobj;
3278 }
3279
3280
3281 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3282 PyObject *resultobj;
3283 wxObject *arg1 = (wxObject *) 0 ;
3284 wxString result;
3285 PyObject * obj0 = 0 ;
3286 char *kwnames[] = {
3287 (char *) "self", NULL
3288 };
3289
3290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3292 if (SWIG_arg_fail(1)) SWIG_fail;
3293 {
3294 PyThreadState* __tstate = wxPyBeginAllowThreads();
3295 result = wxObject_GetClassName(arg1);
3296
3297 wxPyEndAllowThreads(__tstate);
3298 if (PyErr_Occurred()) SWIG_fail;
3299 }
3300 {
3301 #if wxUSE_UNICODE
3302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3303 #else
3304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3305 #endif
3306 }
3307 return resultobj;
3308 fail:
3309 return NULL;
3310 }
3311
3312
3313 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3314 PyObject *resultobj;
3315 wxObject *arg1 = (wxObject *) 0 ;
3316 PyObject * obj0 = 0 ;
3317 char *kwnames[] = {
3318 (char *) "self", NULL
3319 };
3320
3321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3323 if (SWIG_arg_fail(1)) SWIG_fail;
3324 {
3325 PyThreadState* __tstate = wxPyBeginAllowThreads();
3326 wxObject_Destroy(arg1);
3327
3328 wxPyEndAllowThreads(__tstate);
3329 if (PyErr_Occurred()) SWIG_fail;
3330 }
3331 Py_INCREF(Py_None); resultobj = Py_None;
3332 return resultobj;
3333 fail:
3334 return NULL;
3335 }
3336
3337
3338 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3339 PyObject *obj;
3340 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3341 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3342 Py_INCREF(obj);
3343 return Py_BuildValue((char *)"");
3344 }
3345 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3346 PyObject *resultobj;
3347 wxSize *arg1 = (wxSize *) 0 ;
3348 int arg2 ;
3349 PyObject * obj0 = 0 ;
3350 PyObject * obj1 = 0 ;
3351 char *kwnames[] = {
3352 (char *) "self",(char *) "x", NULL
3353 };
3354
3355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3357 if (SWIG_arg_fail(1)) SWIG_fail;
3358 {
3359 arg2 = (int)(SWIG_As_int(obj1));
3360 if (SWIG_arg_fail(2)) SWIG_fail;
3361 }
3362 if (arg1) (arg1)->x = arg2;
3363
3364 Py_INCREF(Py_None); resultobj = Py_None;
3365 return resultobj;
3366 fail:
3367 return NULL;
3368 }
3369
3370
3371 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3372 PyObject *resultobj;
3373 wxSize *arg1 = (wxSize *) 0 ;
3374 int result;
3375 PyObject * obj0 = 0 ;
3376 char *kwnames[] = {
3377 (char *) "self", NULL
3378 };
3379
3380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3382 if (SWIG_arg_fail(1)) SWIG_fail;
3383 result = (int) ((arg1)->x);
3384
3385 {
3386 resultobj = SWIG_From_int((int)(result));
3387 }
3388 return resultobj;
3389 fail:
3390 return NULL;
3391 }
3392
3393
3394 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3395 PyObject *resultobj;
3396 wxSize *arg1 = (wxSize *) 0 ;
3397 int arg2 ;
3398 PyObject * obj0 = 0 ;
3399 PyObject * obj1 = 0 ;
3400 char *kwnames[] = {
3401 (char *) "self",(char *) "y", NULL
3402 };
3403
3404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3406 if (SWIG_arg_fail(1)) SWIG_fail;
3407 {
3408 arg2 = (int)(SWIG_As_int(obj1));
3409 if (SWIG_arg_fail(2)) SWIG_fail;
3410 }
3411 if (arg1) (arg1)->y = arg2;
3412
3413 Py_INCREF(Py_None); resultobj = Py_None;
3414 return resultobj;
3415 fail:
3416 return NULL;
3417 }
3418
3419
3420 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3421 PyObject *resultobj;
3422 wxSize *arg1 = (wxSize *) 0 ;
3423 int result;
3424 PyObject * obj0 = 0 ;
3425 char *kwnames[] = {
3426 (char *) "self", NULL
3427 };
3428
3429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3431 if (SWIG_arg_fail(1)) SWIG_fail;
3432 result = (int) ((arg1)->y);
3433
3434 {
3435 resultobj = SWIG_From_int((int)(result));
3436 }
3437 return resultobj;
3438 fail:
3439 return NULL;
3440 }
3441
3442
3443 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3444 PyObject *resultobj;
3445 int arg1 = (int) 0 ;
3446 int arg2 = (int) 0 ;
3447 wxSize *result;
3448 PyObject * obj0 = 0 ;
3449 PyObject * obj1 = 0 ;
3450 char *kwnames[] = {
3451 (char *) "w",(char *) "h", NULL
3452 };
3453
3454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3455 if (obj0) {
3456 {
3457 arg1 = (int)(SWIG_As_int(obj0));
3458 if (SWIG_arg_fail(1)) SWIG_fail;
3459 }
3460 }
3461 if (obj1) {
3462 {
3463 arg2 = (int)(SWIG_As_int(obj1));
3464 if (SWIG_arg_fail(2)) SWIG_fail;
3465 }
3466 }
3467 {
3468 PyThreadState* __tstate = wxPyBeginAllowThreads();
3469 result = (wxSize *)new wxSize(arg1,arg2);
3470
3471 wxPyEndAllowThreads(__tstate);
3472 if (PyErr_Occurred()) SWIG_fail;
3473 }
3474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3475 return resultobj;
3476 fail:
3477 return NULL;
3478 }
3479
3480
3481 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3482 PyObject *resultobj;
3483 wxSize *arg1 = (wxSize *) 0 ;
3484 PyObject * obj0 = 0 ;
3485 char *kwnames[] = {
3486 (char *) "self", NULL
3487 };
3488
3489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3491 if (SWIG_arg_fail(1)) SWIG_fail;
3492 {
3493 PyThreadState* __tstate = wxPyBeginAllowThreads();
3494 delete arg1;
3495
3496 wxPyEndAllowThreads(__tstate);
3497 if (PyErr_Occurred()) SWIG_fail;
3498 }
3499 Py_INCREF(Py_None); resultobj = Py_None;
3500 return resultobj;
3501 fail:
3502 return NULL;
3503 }
3504
3505
3506 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3507 PyObject *resultobj;
3508 wxSize *arg1 = (wxSize *) 0 ;
3509 wxSize *arg2 = 0 ;
3510 bool result;
3511 wxSize temp2 ;
3512 PyObject * obj0 = 0 ;
3513 PyObject * obj1 = 0 ;
3514 char *kwnames[] = {
3515 (char *) "self",(char *) "sz", NULL
3516 };
3517
3518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3520 if (SWIG_arg_fail(1)) SWIG_fail;
3521 {
3522 arg2 = &temp2;
3523 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3524 }
3525 {
3526 PyThreadState* __tstate = wxPyBeginAllowThreads();
3527 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3528
3529 wxPyEndAllowThreads(__tstate);
3530 if (PyErr_Occurred()) SWIG_fail;
3531 }
3532 {
3533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3534 }
3535 return resultobj;
3536 fail:
3537 return NULL;
3538 }
3539
3540
3541 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3542 PyObject *resultobj;
3543 wxSize *arg1 = (wxSize *) 0 ;
3544 wxSize *arg2 = 0 ;
3545 bool result;
3546 wxSize temp2 ;
3547 PyObject * obj0 = 0 ;
3548 PyObject * obj1 = 0 ;
3549 char *kwnames[] = {
3550 (char *) "self",(char *) "sz", NULL
3551 };
3552
3553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3555 if (SWIG_arg_fail(1)) SWIG_fail;
3556 {
3557 arg2 = &temp2;
3558 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3559 }
3560 {
3561 PyThreadState* __tstate = wxPyBeginAllowThreads();
3562 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3563
3564 wxPyEndAllowThreads(__tstate);
3565 if (PyErr_Occurred()) SWIG_fail;
3566 }
3567 {
3568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3569 }
3570 return resultobj;
3571 fail:
3572 return NULL;
3573 }
3574
3575
3576 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3577 PyObject *resultobj;
3578 wxSize *arg1 = (wxSize *) 0 ;
3579 wxSize *arg2 = 0 ;
3580 wxSize result;
3581 wxSize temp2 ;
3582 PyObject * obj0 = 0 ;
3583 PyObject * obj1 = 0 ;
3584 char *kwnames[] = {
3585 (char *) "self",(char *) "sz", NULL
3586 };
3587
3588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3590 if (SWIG_arg_fail(1)) SWIG_fail;
3591 {
3592 arg2 = &temp2;
3593 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3594 }
3595 {
3596 PyThreadState* __tstate = wxPyBeginAllowThreads();
3597 result = (arg1)->operator +((wxSize const &)*arg2);
3598
3599 wxPyEndAllowThreads(__tstate);
3600 if (PyErr_Occurred()) SWIG_fail;
3601 }
3602 {
3603 wxSize * resultptr;
3604 resultptr = new wxSize((wxSize &)(result));
3605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3606 }
3607 return resultobj;
3608 fail:
3609 return NULL;
3610 }
3611
3612
3613 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3614 PyObject *resultobj;
3615 wxSize *arg1 = (wxSize *) 0 ;
3616 wxSize *arg2 = 0 ;
3617 wxSize result;
3618 wxSize temp2 ;
3619 PyObject * obj0 = 0 ;
3620 PyObject * obj1 = 0 ;
3621 char *kwnames[] = {
3622 (char *) "self",(char *) "sz", NULL
3623 };
3624
3625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3627 if (SWIG_arg_fail(1)) SWIG_fail;
3628 {
3629 arg2 = &temp2;
3630 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3631 }
3632 {
3633 PyThreadState* __tstate = wxPyBeginAllowThreads();
3634 result = (arg1)->operator -((wxSize const &)*arg2);
3635
3636 wxPyEndAllowThreads(__tstate);
3637 if (PyErr_Occurred()) SWIG_fail;
3638 }
3639 {
3640 wxSize * resultptr;
3641 resultptr = new wxSize((wxSize &)(result));
3642 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3643 }
3644 return resultobj;
3645 fail:
3646 return NULL;
3647 }
3648
3649
3650 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3651 PyObject *resultobj;
3652 wxSize *arg1 = (wxSize *) 0 ;
3653 wxSize *arg2 = 0 ;
3654 wxSize temp2 ;
3655 PyObject * obj0 = 0 ;
3656 PyObject * obj1 = 0 ;
3657 char *kwnames[] = {
3658 (char *) "self",(char *) "sz", NULL
3659 };
3660
3661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3663 if (SWIG_arg_fail(1)) SWIG_fail;
3664 {
3665 arg2 = &temp2;
3666 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3667 }
3668 {
3669 PyThreadState* __tstate = wxPyBeginAllowThreads();
3670 (arg1)->IncTo((wxSize const &)*arg2);
3671
3672 wxPyEndAllowThreads(__tstate);
3673 if (PyErr_Occurred()) SWIG_fail;
3674 }
3675 Py_INCREF(Py_None); resultobj = Py_None;
3676 return resultobj;
3677 fail:
3678 return NULL;
3679 }
3680
3681
3682 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3683 PyObject *resultobj;
3684 wxSize *arg1 = (wxSize *) 0 ;
3685 wxSize *arg2 = 0 ;
3686 wxSize temp2 ;
3687 PyObject * obj0 = 0 ;
3688 PyObject * obj1 = 0 ;
3689 char *kwnames[] = {
3690 (char *) "self",(char *) "sz", NULL
3691 };
3692
3693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3695 if (SWIG_arg_fail(1)) SWIG_fail;
3696 {
3697 arg2 = &temp2;
3698 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3699 }
3700 {
3701 PyThreadState* __tstate = wxPyBeginAllowThreads();
3702 (arg1)->DecTo((wxSize const &)*arg2);
3703
3704 wxPyEndAllowThreads(__tstate);
3705 if (PyErr_Occurred()) SWIG_fail;
3706 }
3707 Py_INCREF(Py_None); resultobj = Py_None;
3708 return resultobj;
3709 fail:
3710 return NULL;
3711 }
3712
3713
3714 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3715 PyObject *resultobj;
3716 wxSize *arg1 = (wxSize *) 0 ;
3717 int arg2 ;
3718 int arg3 ;
3719 PyObject * obj0 = 0 ;
3720 PyObject * obj1 = 0 ;
3721 PyObject * obj2 = 0 ;
3722 char *kwnames[] = {
3723 (char *) "self",(char *) "w",(char *) "h", NULL
3724 };
3725
3726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3728 if (SWIG_arg_fail(1)) SWIG_fail;
3729 {
3730 arg2 = (int)(SWIG_As_int(obj1));
3731 if (SWIG_arg_fail(2)) SWIG_fail;
3732 }
3733 {
3734 arg3 = (int)(SWIG_As_int(obj2));
3735 if (SWIG_arg_fail(3)) SWIG_fail;
3736 }
3737 {
3738 PyThreadState* __tstate = wxPyBeginAllowThreads();
3739 (arg1)->Set(arg2,arg3);
3740
3741 wxPyEndAllowThreads(__tstate);
3742 if (PyErr_Occurred()) SWIG_fail;
3743 }
3744 Py_INCREF(Py_None); resultobj = Py_None;
3745 return resultobj;
3746 fail:
3747 return NULL;
3748 }
3749
3750
3751 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3752 PyObject *resultobj;
3753 wxSize *arg1 = (wxSize *) 0 ;
3754 int arg2 ;
3755 PyObject * obj0 = 0 ;
3756 PyObject * obj1 = 0 ;
3757 char *kwnames[] = {
3758 (char *) "self",(char *) "w", NULL
3759 };
3760
3761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3763 if (SWIG_arg_fail(1)) SWIG_fail;
3764 {
3765 arg2 = (int)(SWIG_As_int(obj1));
3766 if (SWIG_arg_fail(2)) SWIG_fail;
3767 }
3768 {
3769 PyThreadState* __tstate = wxPyBeginAllowThreads();
3770 (arg1)->SetWidth(arg2);
3771
3772 wxPyEndAllowThreads(__tstate);
3773 if (PyErr_Occurred()) SWIG_fail;
3774 }
3775 Py_INCREF(Py_None); resultobj = Py_None;
3776 return resultobj;
3777 fail:
3778 return NULL;
3779 }
3780
3781
3782 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3783 PyObject *resultobj;
3784 wxSize *arg1 = (wxSize *) 0 ;
3785 int arg2 ;
3786 PyObject * obj0 = 0 ;
3787 PyObject * obj1 = 0 ;
3788 char *kwnames[] = {
3789 (char *) "self",(char *) "h", NULL
3790 };
3791
3792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3794 if (SWIG_arg_fail(1)) SWIG_fail;
3795 {
3796 arg2 = (int)(SWIG_As_int(obj1));
3797 if (SWIG_arg_fail(2)) SWIG_fail;
3798 }
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 (arg1)->SetHeight(arg2);
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 Py_INCREF(Py_None); resultobj = Py_None;
3807 return resultobj;
3808 fail:
3809 return NULL;
3810 }
3811
3812
3813 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3814 PyObject *resultobj;
3815 wxSize *arg1 = (wxSize *) 0 ;
3816 int result;
3817 PyObject * obj0 = 0 ;
3818 char *kwnames[] = {
3819 (char *) "self", NULL
3820 };
3821
3822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3824 if (SWIG_arg_fail(1)) SWIG_fail;
3825 {
3826 PyThreadState* __tstate = wxPyBeginAllowThreads();
3827 result = (int)((wxSize const *)arg1)->GetWidth();
3828
3829 wxPyEndAllowThreads(__tstate);
3830 if (PyErr_Occurred()) SWIG_fail;
3831 }
3832 {
3833 resultobj = SWIG_From_int((int)(result));
3834 }
3835 return resultobj;
3836 fail:
3837 return NULL;
3838 }
3839
3840
3841 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3842 PyObject *resultobj;
3843 wxSize *arg1 = (wxSize *) 0 ;
3844 int result;
3845 PyObject * obj0 = 0 ;
3846 char *kwnames[] = {
3847 (char *) "self", NULL
3848 };
3849
3850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3852 if (SWIG_arg_fail(1)) SWIG_fail;
3853 {
3854 PyThreadState* __tstate = wxPyBeginAllowThreads();
3855 result = (int)((wxSize const *)arg1)->GetHeight();
3856
3857 wxPyEndAllowThreads(__tstate);
3858 if (PyErr_Occurred()) SWIG_fail;
3859 }
3860 {
3861 resultobj = SWIG_From_int((int)(result));
3862 }
3863 return resultobj;
3864 fail:
3865 return NULL;
3866 }
3867
3868
3869 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3870 PyObject *resultobj;
3871 wxSize *arg1 = (wxSize *) 0 ;
3872 bool result;
3873 PyObject * obj0 = 0 ;
3874 char *kwnames[] = {
3875 (char *) "self", NULL
3876 };
3877
3878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3880 if (SWIG_arg_fail(1)) SWIG_fail;
3881 {
3882 PyThreadState* __tstate = wxPyBeginAllowThreads();
3883 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3884
3885 wxPyEndAllowThreads(__tstate);
3886 if (PyErr_Occurred()) SWIG_fail;
3887 }
3888 {
3889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3890 }
3891 return resultobj;
3892 fail:
3893 return NULL;
3894 }
3895
3896
3897 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3898 PyObject *resultobj;
3899 wxSize *arg1 = (wxSize *) 0 ;
3900 wxSize *arg2 = 0 ;
3901 wxSize temp2 ;
3902 PyObject * obj0 = 0 ;
3903 PyObject * obj1 = 0 ;
3904 char *kwnames[] = {
3905 (char *) "self",(char *) "size", NULL
3906 };
3907
3908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3910 if (SWIG_arg_fail(1)) SWIG_fail;
3911 {
3912 arg2 = &temp2;
3913 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3914 }
3915 {
3916 PyThreadState* __tstate = wxPyBeginAllowThreads();
3917 (arg1)->SetDefaults((wxSize const &)*arg2);
3918
3919 wxPyEndAllowThreads(__tstate);
3920 if (PyErr_Occurred()) SWIG_fail;
3921 }
3922 Py_INCREF(Py_None); resultobj = Py_None;
3923 return resultobj;
3924 fail:
3925 return NULL;
3926 }
3927
3928
3929 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3930 PyObject *resultobj;
3931 wxSize *arg1 = (wxSize *) 0 ;
3932 PyObject *result;
3933 PyObject * obj0 = 0 ;
3934 char *kwnames[] = {
3935 (char *) "self", NULL
3936 };
3937
3938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3940 if (SWIG_arg_fail(1)) SWIG_fail;
3941 {
3942 PyThreadState* __tstate = wxPyBeginAllowThreads();
3943 result = (PyObject *)wxSize_Get(arg1);
3944
3945 wxPyEndAllowThreads(__tstate);
3946 if (PyErr_Occurred()) SWIG_fail;
3947 }
3948 resultobj = result;
3949 return resultobj;
3950 fail:
3951 return NULL;
3952 }
3953
3954
3955 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3956 PyObject *obj;
3957 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3958 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3959 Py_INCREF(obj);
3960 return Py_BuildValue((char *)"");
3961 }
3962 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3963 PyObject *resultobj;
3964 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3965 double arg2 ;
3966 PyObject * obj0 = 0 ;
3967 PyObject * obj1 = 0 ;
3968 char *kwnames[] = {
3969 (char *) "self",(char *) "x", NULL
3970 };
3971
3972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3974 if (SWIG_arg_fail(1)) SWIG_fail;
3975 {
3976 arg2 = (double)(SWIG_As_double(obj1));
3977 if (SWIG_arg_fail(2)) SWIG_fail;
3978 }
3979 if (arg1) (arg1)->x = arg2;
3980
3981 Py_INCREF(Py_None); resultobj = Py_None;
3982 return resultobj;
3983 fail:
3984 return NULL;
3985 }
3986
3987
3988 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3989 PyObject *resultobj;
3990 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3991 double result;
3992 PyObject * obj0 = 0 ;
3993 char *kwnames[] = {
3994 (char *) "self", NULL
3995 };
3996
3997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3999 if (SWIG_arg_fail(1)) SWIG_fail;
4000 result = (double) ((arg1)->x);
4001
4002 {
4003 resultobj = SWIG_From_double((double)(result));
4004 }
4005 return resultobj;
4006 fail:
4007 return NULL;
4008 }
4009
4010
4011 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4012 PyObject *resultobj;
4013 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4014 double arg2 ;
4015 PyObject * obj0 = 0 ;
4016 PyObject * obj1 = 0 ;
4017 char *kwnames[] = {
4018 (char *) "self",(char *) "y", NULL
4019 };
4020
4021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4023 if (SWIG_arg_fail(1)) SWIG_fail;
4024 {
4025 arg2 = (double)(SWIG_As_double(obj1));
4026 if (SWIG_arg_fail(2)) SWIG_fail;
4027 }
4028 if (arg1) (arg1)->y = arg2;
4029
4030 Py_INCREF(Py_None); resultobj = Py_None;
4031 return resultobj;
4032 fail:
4033 return NULL;
4034 }
4035
4036
4037 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4038 PyObject *resultobj;
4039 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4040 double result;
4041 PyObject * obj0 = 0 ;
4042 char *kwnames[] = {
4043 (char *) "self", NULL
4044 };
4045
4046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4048 if (SWIG_arg_fail(1)) SWIG_fail;
4049 result = (double) ((arg1)->y);
4050
4051 {
4052 resultobj = SWIG_From_double((double)(result));
4053 }
4054 return resultobj;
4055 fail:
4056 return NULL;
4057 }
4058
4059
4060 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4061 PyObject *resultobj;
4062 double arg1 = (double) 0.0 ;
4063 double arg2 = (double) 0.0 ;
4064 wxRealPoint *result;
4065 PyObject * obj0 = 0 ;
4066 PyObject * obj1 = 0 ;
4067 char *kwnames[] = {
4068 (char *) "x",(char *) "y", NULL
4069 };
4070
4071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4072 if (obj0) {
4073 {
4074 arg1 = (double)(SWIG_As_double(obj0));
4075 if (SWIG_arg_fail(1)) SWIG_fail;
4076 }
4077 }
4078 if (obj1) {
4079 {
4080 arg2 = (double)(SWIG_As_double(obj1));
4081 if (SWIG_arg_fail(2)) SWIG_fail;
4082 }
4083 }
4084 {
4085 PyThreadState* __tstate = wxPyBeginAllowThreads();
4086 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4087
4088 wxPyEndAllowThreads(__tstate);
4089 if (PyErr_Occurred()) SWIG_fail;
4090 }
4091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4092 return resultobj;
4093 fail:
4094 return NULL;
4095 }
4096
4097
4098 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4099 PyObject *resultobj;
4100 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4101 PyObject * obj0 = 0 ;
4102 char *kwnames[] = {
4103 (char *) "self", NULL
4104 };
4105
4106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4108 if (SWIG_arg_fail(1)) SWIG_fail;
4109 {
4110 PyThreadState* __tstate = wxPyBeginAllowThreads();
4111 delete arg1;
4112
4113 wxPyEndAllowThreads(__tstate);
4114 if (PyErr_Occurred()) SWIG_fail;
4115 }
4116 Py_INCREF(Py_None); resultobj = Py_None;
4117 return resultobj;
4118 fail:
4119 return NULL;
4120 }
4121
4122
4123 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4124 PyObject *resultobj;
4125 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4126 wxRealPoint *arg2 = 0 ;
4127 bool result;
4128 wxRealPoint temp2 ;
4129 PyObject * obj0 = 0 ;
4130 PyObject * obj1 = 0 ;
4131 char *kwnames[] = {
4132 (char *) "self",(char *) "pt", NULL
4133 };
4134
4135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4137 if (SWIG_arg_fail(1)) SWIG_fail;
4138 {
4139 arg2 = &temp2;
4140 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4141 }
4142 {
4143 PyThreadState* __tstate = wxPyBeginAllowThreads();
4144 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4145
4146 wxPyEndAllowThreads(__tstate);
4147 if (PyErr_Occurred()) SWIG_fail;
4148 }
4149 {
4150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4151 }
4152 return resultobj;
4153 fail:
4154 return NULL;
4155 }
4156
4157
4158 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4159 PyObject *resultobj;
4160 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4161 wxRealPoint *arg2 = 0 ;
4162 bool result;
4163 wxRealPoint temp2 ;
4164 PyObject * obj0 = 0 ;
4165 PyObject * obj1 = 0 ;
4166 char *kwnames[] = {
4167 (char *) "self",(char *) "pt", NULL
4168 };
4169
4170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4172 if (SWIG_arg_fail(1)) SWIG_fail;
4173 {
4174 arg2 = &temp2;
4175 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4176 }
4177 {
4178 PyThreadState* __tstate = wxPyBeginAllowThreads();
4179 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4180
4181 wxPyEndAllowThreads(__tstate);
4182 if (PyErr_Occurred()) SWIG_fail;
4183 }
4184 {
4185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4186 }
4187 return resultobj;
4188 fail:
4189 return NULL;
4190 }
4191
4192
4193 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4194 PyObject *resultobj;
4195 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4196 wxRealPoint *arg2 = 0 ;
4197 wxRealPoint result;
4198 wxRealPoint temp2 ;
4199 PyObject * obj0 = 0 ;
4200 PyObject * obj1 = 0 ;
4201 char *kwnames[] = {
4202 (char *) "self",(char *) "pt", NULL
4203 };
4204
4205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4207 if (SWIG_arg_fail(1)) SWIG_fail;
4208 {
4209 arg2 = &temp2;
4210 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4211 }
4212 {
4213 PyThreadState* __tstate = wxPyBeginAllowThreads();
4214 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4215
4216 wxPyEndAllowThreads(__tstate);
4217 if (PyErr_Occurred()) SWIG_fail;
4218 }
4219 {
4220 wxRealPoint * resultptr;
4221 resultptr = new wxRealPoint((wxRealPoint &)(result));
4222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4223 }
4224 return resultobj;
4225 fail:
4226 return NULL;
4227 }
4228
4229
4230 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4231 PyObject *resultobj;
4232 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4233 wxRealPoint *arg2 = 0 ;
4234 wxRealPoint result;
4235 wxRealPoint temp2 ;
4236 PyObject * obj0 = 0 ;
4237 PyObject * obj1 = 0 ;
4238 char *kwnames[] = {
4239 (char *) "self",(char *) "pt", NULL
4240 };
4241
4242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4244 if (SWIG_arg_fail(1)) SWIG_fail;
4245 {
4246 arg2 = &temp2;
4247 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4248 }
4249 {
4250 PyThreadState* __tstate = wxPyBeginAllowThreads();
4251 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4252
4253 wxPyEndAllowThreads(__tstate);
4254 if (PyErr_Occurred()) SWIG_fail;
4255 }
4256 {
4257 wxRealPoint * resultptr;
4258 resultptr = new wxRealPoint((wxRealPoint &)(result));
4259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4260 }
4261 return resultobj;
4262 fail:
4263 return NULL;
4264 }
4265
4266
4267 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4268 PyObject *resultobj;
4269 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4270 double arg2 ;
4271 double arg3 ;
4272 PyObject * obj0 = 0 ;
4273 PyObject * obj1 = 0 ;
4274 PyObject * obj2 = 0 ;
4275 char *kwnames[] = {
4276 (char *) "self",(char *) "x",(char *) "y", NULL
4277 };
4278
4279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4281 if (SWIG_arg_fail(1)) SWIG_fail;
4282 {
4283 arg2 = (double)(SWIG_As_double(obj1));
4284 if (SWIG_arg_fail(2)) SWIG_fail;
4285 }
4286 {
4287 arg3 = (double)(SWIG_As_double(obj2));
4288 if (SWIG_arg_fail(3)) SWIG_fail;
4289 }
4290 {
4291 PyThreadState* __tstate = wxPyBeginAllowThreads();
4292 wxRealPoint_Set(arg1,arg2,arg3);
4293
4294 wxPyEndAllowThreads(__tstate);
4295 if (PyErr_Occurred()) SWIG_fail;
4296 }
4297 Py_INCREF(Py_None); resultobj = Py_None;
4298 return resultobj;
4299 fail:
4300 return NULL;
4301 }
4302
4303
4304 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4305 PyObject *resultobj;
4306 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4307 PyObject *result;
4308 PyObject * obj0 = 0 ;
4309 char *kwnames[] = {
4310 (char *) "self", NULL
4311 };
4312
4313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4315 if (SWIG_arg_fail(1)) SWIG_fail;
4316 {
4317 PyThreadState* __tstate = wxPyBeginAllowThreads();
4318 result = (PyObject *)wxRealPoint_Get(arg1);
4319
4320 wxPyEndAllowThreads(__tstate);
4321 if (PyErr_Occurred()) SWIG_fail;
4322 }
4323 resultobj = result;
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4331 PyObject *obj;
4332 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4333 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4334 Py_INCREF(obj);
4335 return Py_BuildValue((char *)"");
4336 }
4337 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4338 PyObject *resultobj;
4339 wxPoint *arg1 = (wxPoint *) 0 ;
4340 int arg2 ;
4341 PyObject * obj0 = 0 ;
4342 PyObject * obj1 = 0 ;
4343 char *kwnames[] = {
4344 (char *) "self",(char *) "x", NULL
4345 };
4346
4347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4349 if (SWIG_arg_fail(1)) SWIG_fail;
4350 {
4351 arg2 = (int)(SWIG_As_int(obj1));
4352 if (SWIG_arg_fail(2)) SWIG_fail;
4353 }
4354 if (arg1) (arg1)->x = arg2;
4355
4356 Py_INCREF(Py_None); resultobj = Py_None;
4357 return resultobj;
4358 fail:
4359 return NULL;
4360 }
4361
4362
4363 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4364 PyObject *resultobj;
4365 wxPoint *arg1 = (wxPoint *) 0 ;
4366 int result;
4367 PyObject * obj0 = 0 ;
4368 char *kwnames[] = {
4369 (char *) "self", NULL
4370 };
4371
4372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4374 if (SWIG_arg_fail(1)) SWIG_fail;
4375 result = (int) ((arg1)->x);
4376
4377 {
4378 resultobj = SWIG_From_int((int)(result));
4379 }
4380 return resultobj;
4381 fail:
4382 return NULL;
4383 }
4384
4385
4386 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4387 PyObject *resultobj;
4388 wxPoint *arg1 = (wxPoint *) 0 ;
4389 int arg2 ;
4390 PyObject * obj0 = 0 ;
4391 PyObject * obj1 = 0 ;
4392 char *kwnames[] = {
4393 (char *) "self",(char *) "y", NULL
4394 };
4395
4396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4398 if (SWIG_arg_fail(1)) SWIG_fail;
4399 {
4400 arg2 = (int)(SWIG_As_int(obj1));
4401 if (SWIG_arg_fail(2)) SWIG_fail;
4402 }
4403 if (arg1) (arg1)->y = arg2;
4404
4405 Py_INCREF(Py_None); resultobj = Py_None;
4406 return resultobj;
4407 fail:
4408 return NULL;
4409 }
4410
4411
4412 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4413 PyObject *resultobj;
4414 wxPoint *arg1 = (wxPoint *) 0 ;
4415 int result;
4416 PyObject * obj0 = 0 ;
4417 char *kwnames[] = {
4418 (char *) "self", NULL
4419 };
4420
4421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4423 if (SWIG_arg_fail(1)) SWIG_fail;
4424 result = (int) ((arg1)->y);
4425
4426 {
4427 resultobj = SWIG_From_int((int)(result));
4428 }
4429 return resultobj;
4430 fail:
4431 return NULL;
4432 }
4433
4434
4435 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4436 PyObject *resultobj;
4437 int arg1 = (int) 0 ;
4438 int arg2 = (int) 0 ;
4439 wxPoint *result;
4440 PyObject * obj0 = 0 ;
4441 PyObject * obj1 = 0 ;
4442 char *kwnames[] = {
4443 (char *) "x",(char *) "y", NULL
4444 };
4445
4446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4447 if (obj0) {
4448 {
4449 arg1 = (int)(SWIG_As_int(obj0));
4450 if (SWIG_arg_fail(1)) SWIG_fail;
4451 }
4452 }
4453 if (obj1) {
4454 {
4455 arg2 = (int)(SWIG_As_int(obj1));
4456 if (SWIG_arg_fail(2)) SWIG_fail;
4457 }
4458 }
4459 {
4460 PyThreadState* __tstate = wxPyBeginAllowThreads();
4461 result = (wxPoint *)new wxPoint(arg1,arg2);
4462
4463 wxPyEndAllowThreads(__tstate);
4464 if (PyErr_Occurred()) SWIG_fail;
4465 }
4466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4467 return resultobj;
4468 fail:
4469 return NULL;
4470 }
4471
4472
4473 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4474 PyObject *resultobj;
4475 wxPoint *arg1 = (wxPoint *) 0 ;
4476 PyObject * obj0 = 0 ;
4477 char *kwnames[] = {
4478 (char *) "self", NULL
4479 };
4480
4481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4483 if (SWIG_arg_fail(1)) SWIG_fail;
4484 {
4485 PyThreadState* __tstate = wxPyBeginAllowThreads();
4486 delete arg1;
4487
4488 wxPyEndAllowThreads(__tstate);
4489 if (PyErr_Occurred()) SWIG_fail;
4490 }
4491 Py_INCREF(Py_None); resultobj = Py_None;
4492 return resultobj;
4493 fail:
4494 return NULL;
4495 }
4496
4497
4498 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4499 PyObject *resultobj;
4500 wxPoint *arg1 = (wxPoint *) 0 ;
4501 wxPoint *arg2 = 0 ;
4502 bool result;
4503 wxPoint temp2 ;
4504 PyObject * obj0 = 0 ;
4505 PyObject * obj1 = 0 ;
4506 char *kwnames[] = {
4507 (char *) "self",(char *) "pt", NULL
4508 };
4509
4510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4512 if (SWIG_arg_fail(1)) SWIG_fail;
4513 {
4514 arg2 = &temp2;
4515 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4516 }
4517 {
4518 PyThreadState* __tstate = wxPyBeginAllowThreads();
4519 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4520
4521 wxPyEndAllowThreads(__tstate);
4522 if (PyErr_Occurred()) SWIG_fail;
4523 }
4524 {
4525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4526 }
4527 return resultobj;
4528 fail:
4529 return NULL;
4530 }
4531
4532
4533 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4534 PyObject *resultobj;
4535 wxPoint *arg1 = (wxPoint *) 0 ;
4536 wxPoint *arg2 = 0 ;
4537 bool result;
4538 wxPoint temp2 ;
4539 PyObject * obj0 = 0 ;
4540 PyObject * obj1 = 0 ;
4541 char *kwnames[] = {
4542 (char *) "self",(char *) "pt", NULL
4543 };
4544
4545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4547 if (SWIG_arg_fail(1)) SWIG_fail;
4548 {
4549 arg2 = &temp2;
4550 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4551 }
4552 {
4553 PyThreadState* __tstate = wxPyBeginAllowThreads();
4554 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4555
4556 wxPyEndAllowThreads(__tstate);
4557 if (PyErr_Occurred()) SWIG_fail;
4558 }
4559 {
4560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4561 }
4562 return resultobj;
4563 fail:
4564 return NULL;
4565 }
4566
4567
4568 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4569 PyObject *resultobj;
4570 wxPoint *arg1 = (wxPoint *) 0 ;
4571 wxPoint *arg2 = 0 ;
4572 wxPoint result;
4573 wxPoint temp2 ;
4574 PyObject * obj0 = 0 ;
4575 PyObject * obj1 = 0 ;
4576 char *kwnames[] = {
4577 (char *) "self",(char *) "pt", NULL
4578 };
4579
4580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4582 if (SWIG_arg_fail(1)) SWIG_fail;
4583 {
4584 arg2 = &temp2;
4585 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4586 }
4587 {
4588 PyThreadState* __tstate = wxPyBeginAllowThreads();
4589 result = (arg1)->operator +((wxPoint const &)*arg2);
4590
4591 wxPyEndAllowThreads(__tstate);
4592 if (PyErr_Occurred()) SWIG_fail;
4593 }
4594 {
4595 wxPoint * resultptr;
4596 resultptr = new wxPoint((wxPoint &)(result));
4597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4598 }
4599 return resultobj;
4600 fail:
4601 return NULL;
4602 }
4603
4604
4605 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4606 PyObject *resultobj;
4607 wxPoint *arg1 = (wxPoint *) 0 ;
4608 wxPoint *arg2 = 0 ;
4609 wxPoint result;
4610 wxPoint temp2 ;
4611 PyObject * obj0 = 0 ;
4612 PyObject * obj1 = 0 ;
4613 char *kwnames[] = {
4614 (char *) "self",(char *) "pt", NULL
4615 };
4616
4617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4619 if (SWIG_arg_fail(1)) SWIG_fail;
4620 {
4621 arg2 = &temp2;
4622 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4623 }
4624 {
4625 PyThreadState* __tstate = wxPyBeginAllowThreads();
4626 result = (arg1)->operator -((wxPoint const &)*arg2);
4627
4628 wxPyEndAllowThreads(__tstate);
4629 if (PyErr_Occurred()) SWIG_fail;
4630 }
4631 {
4632 wxPoint * resultptr;
4633 resultptr = new wxPoint((wxPoint &)(result));
4634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4635 }
4636 return resultobj;
4637 fail:
4638 return NULL;
4639 }
4640
4641
4642 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj;
4644 wxPoint *arg1 = (wxPoint *) 0 ;
4645 wxPoint *arg2 = 0 ;
4646 wxPoint *result;
4647 wxPoint temp2 ;
4648 PyObject * obj0 = 0 ;
4649 PyObject * obj1 = 0 ;
4650 char *kwnames[] = {
4651 (char *) "self",(char *) "pt", NULL
4652 };
4653
4654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4656 if (SWIG_arg_fail(1)) SWIG_fail;
4657 {
4658 arg2 = &temp2;
4659 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4660 }
4661 {
4662 PyThreadState* __tstate = wxPyBeginAllowThreads();
4663 {
4664 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4665 result = (wxPoint *) &_result_ref;
4666 }
4667
4668 wxPyEndAllowThreads(__tstate);
4669 if (PyErr_Occurred()) SWIG_fail;
4670 }
4671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4672 return resultobj;
4673 fail:
4674 return NULL;
4675 }
4676
4677
4678 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4679 PyObject *resultobj;
4680 wxPoint *arg1 = (wxPoint *) 0 ;
4681 wxPoint *arg2 = 0 ;
4682 wxPoint *result;
4683 wxPoint temp2 ;
4684 PyObject * obj0 = 0 ;
4685 PyObject * obj1 = 0 ;
4686 char *kwnames[] = {
4687 (char *) "self",(char *) "pt", NULL
4688 };
4689
4690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4692 if (SWIG_arg_fail(1)) SWIG_fail;
4693 {
4694 arg2 = &temp2;
4695 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4696 }
4697 {
4698 PyThreadState* __tstate = wxPyBeginAllowThreads();
4699 {
4700 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4701 result = (wxPoint *) &_result_ref;
4702 }
4703
4704 wxPyEndAllowThreads(__tstate);
4705 if (PyErr_Occurred()) SWIG_fail;
4706 }
4707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4708 return resultobj;
4709 fail:
4710 return NULL;
4711 }
4712
4713
4714 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4715 PyObject *resultobj;
4716 wxPoint *arg1 = (wxPoint *) 0 ;
4717 long arg2 ;
4718 long arg3 ;
4719 PyObject * obj0 = 0 ;
4720 PyObject * obj1 = 0 ;
4721 PyObject * obj2 = 0 ;
4722 char *kwnames[] = {
4723 (char *) "self",(char *) "x",(char *) "y", NULL
4724 };
4725
4726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4728 if (SWIG_arg_fail(1)) SWIG_fail;
4729 {
4730 arg2 = (long)(SWIG_As_long(obj1));
4731 if (SWIG_arg_fail(2)) SWIG_fail;
4732 }
4733 {
4734 arg3 = (long)(SWIG_As_long(obj2));
4735 if (SWIG_arg_fail(3)) SWIG_fail;
4736 }
4737 {
4738 PyThreadState* __tstate = wxPyBeginAllowThreads();
4739 wxPoint_Set(arg1,arg2,arg3);
4740
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 Py_INCREF(Py_None); resultobj = Py_None;
4745 return resultobj;
4746 fail:
4747 return NULL;
4748 }
4749
4750
4751 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4752 PyObject *resultobj;
4753 wxPoint *arg1 = (wxPoint *) 0 ;
4754 PyObject *result;
4755 PyObject * obj0 = 0 ;
4756 char *kwnames[] = {
4757 (char *) "self", NULL
4758 };
4759
4760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4762 if (SWIG_arg_fail(1)) SWIG_fail;
4763 {
4764 PyThreadState* __tstate = wxPyBeginAllowThreads();
4765 result = (PyObject *)wxPoint_Get(arg1);
4766
4767 wxPyEndAllowThreads(__tstate);
4768 if (PyErr_Occurred()) SWIG_fail;
4769 }
4770 resultobj = result;
4771 return resultobj;
4772 fail:
4773 return NULL;
4774 }
4775
4776
4777 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4778 PyObject *obj;
4779 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4780 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4781 Py_INCREF(obj);
4782 return Py_BuildValue((char *)"");
4783 }
4784 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4785 PyObject *resultobj;
4786 int arg1 = (int) 0 ;
4787 int arg2 = (int) 0 ;
4788 int arg3 = (int) 0 ;
4789 int arg4 = (int) 0 ;
4790 wxRect *result;
4791 PyObject * obj0 = 0 ;
4792 PyObject * obj1 = 0 ;
4793 PyObject * obj2 = 0 ;
4794 PyObject * obj3 = 0 ;
4795 char *kwnames[] = {
4796 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4797 };
4798
4799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4800 if (obj0) {
4801 {
4802 arg1 = (int)(SWIG_As_int(obj0));
4803 if (SWIG_arg_fail(1)) SWIG_fail;
4804 }
4805 }
4806 if (obj1) {
4807 {
4808 arg2 = (int)(SWIG_As_int(obj1));
4809 if (SWIG_arg_fail(2)) SWIG_fail;
4810 }
4811 }
4812 if (obj2) {
4813 {
4814 arg3 = (int)(SWIG_As_int(obj2));
4815 if (SWIG_arg_fail(3)) SWIG_fail;
4816 }
4817 }
4818 if (obj3) {
4819 {
4820 arg4 = (int)(SWIG_As_int(obj3));
4821 if (SWIG_arg_fail(4)) SWIG_fail;
4822 }
4823 }
4824 {
4825 PyThreadState* __tstate = wxPyBeginAllowThreads();
4826 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4827
4828 wxPyEndAllowThreads(__tstate);
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4832 return resultobj;
4833 fail:
4834 return NULL;
4835 }
4836
4837
4838 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4839 PyObject *resultobj;
4840 wxPoint *arg1 = 0 ;
4841 wxPoint *arg2 = 0 ;
4842 wxRect *result;
4843 wxPoint temp1 ;
4844 wxPoint temp2 ;
4845 PyObject * obj0 = 0 ;
4846 PyObject * obj1 = 0 ;
4847 char *kwnames[] = {
4848 (char *) "topLeft",(char *) "bottomRight", NULL
4849 };
4850
4851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4852 {
4853 arg1 = &temp1;
4854 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4855 }
4856 {
4857 arg2 = &temp2;
4858 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4859 }
4860 {
4861 PyThreadState* __tstate = wxPyBeginAllowThreads();
4862 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4863
4864 wxPyEndAllowThreads(__tstate);
4865 if (PyErr_Occurred()) SWIG_fail;
4866 }
4867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4868 return resultobj;
4869 fail:
4870 return NULL;
4871 }
4872
4873
4874 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4875 PyObject *resultobj;
4876 wxPoint *arg1 = 0 ;
4877 wxSize *arg2 = 0 ;
4878 wxRect *result;
4879 wxPoint temp1 ;
4880 wxSize temp2 ;
4881 PyObject * obj0 = 0 ;
4882 PyObject * obj1 = 0 ;
4883 char *kwnames[] = {
4884 (char *) "pos",(char *) "size", NULL
4885 };
4886
4887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4888 {
4889 arg1 = &temp1;
4890 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4891 }
4892 {
4893 arg2 = &temp2;
4894 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4895 }
4896 {
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4899
4900 wxPyEndAllowThreads(__tstate);
4901 if (PyErr_Occurred()) SWIG_fail;
4902 }
4903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4904 return resultobj;
4905 fail:
4906 return NULL;
4907 }
4908
4909
4910 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4911 PyObject *resultobj;
4912 wxSize *arg1 = 0 ;
4913 wxRect *result;
4914 wxSize temp1 ;
4915 PyObject * obj0 = 0 ;
4916 char *kwnames[] = {
4917 (char *) "size", NULL
4918 };
4919
4920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4921 {
4922 arg1 = &temp1;
4923 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4924 }
4925 {
4926 PyThreadState* __tstate = wxPyBeginAllowThreads();
4927 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4928
4929 wxPyEndAllowThreads(__tstate);
4930 if (PyErr_Occurred()) SWIG_fail;
4931 }
4932 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4933 return resultobj;
4934 fail:
4935 return NULL;
4936 }
4937
4938
4939 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4940 PyObject *resultobj;
4941 wxRect *arg1 = (wxRect *) 0 ;
4942 PyObject * obj0 = 0 ;
4943 char *kwnames[] = {
4944 (char *) "self", NULL
4945 };
4946
4947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4949 if (SWIG_arg_fail(1)) SWIG_fail;
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 delete arg1;
4953
4954 wxPyEndAllowThreads(__tstate);
4955 if (PyErr_Occurred()) SWIG_fail;
4956 }
4957 Py_INCREF(Py_None); resultobj = Py_None;
4958 return resultobj;
4959 fail:
4960 return NULL;
4961 }
4962
4963
4964 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4965 PyObject *resultobj;
4966 wxRect *arg1 = (wxRect *) 0 ;
4967 int result;
4968 PyObject * obj0 = 0 ;
4969 char *kwnames[] = {
4970 (char *) "self", NULL
4971 };
4972
4973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4975 if (SWIG_arg_fail(1)) SWIG_fail;
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = (int)((wxRect const *)arg1)->GetX();
4979
4980 wxPyEndAllowThreads(__tstate);
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 {
4984 resultobj = SWIG_From_int((int)(result));
4985 }
4986 return resultobj;
4987 fail:
4988 return NULL;
4989 }
4990
4991
4992 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4993 PyObject *resultobj;
4994 wxRect *arg1 = (wxRect *) 0 ;
4995 int arg2 ;
4996 PyObject * obj0 = 0 ;
4997 PyObject * obj1 = 0 ;
4998 char *kwnames[] = {
4999 (char *) "self",(char *) "x", NULL
5000 };
5001
5002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5004 if (SWIG_arg_fail(1)) SWIG_fail;
5005 {
5006 arg2 = (int)(SWIG_As_int(obj1));
5007 if (SWIG_arg_fail(2)) SWIG_fail;
5008 }
5009 {
5010 PyThreadState* __tstate = wxPyBeginAllowThreads();
5011 (arg1)->SetX(arg2);
5012
5013 wxPyEndAllowThreads(__tstate);
5014 if (PyErr_Occurred()) SWIG_fail;
5015 }
5016 Py_INCREF(Py_None); resultobj = Py_None;
5017 return resultobj;
5018 fail:
5019 return NULL;
5020 }
5021
5022
5023 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5024 PyObject *resultobj;
5025 wxRect *arg1 = (wxRect *) 0 ;
5026 int result;
5027 PyObject * obj0 = 0 ;
5028 char *kwnames[] = {
5029 (char *) "self", NULL
5030 };
5031
5032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5034 if (SWIG_arg_fail(1)) SWIG_fail;
5035 {
5036 PyThreadState* __tstate = wxPyBeginAllowThreads();
5037 result = (int)(arg1)->GetY();
5038
5039 wxPyEndAllowThreads(__tstate);
5040 if (PyErr_Occurred()) SWIG_fail;
5041 }
5042 {
5043 resultobj = SWIG_From_int((int)(result));
5044 }
5045 return resultobj;
5046 fail:
5047 return NULL;
5048 }
5049
5050
5051 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5052 PyObject *resultobj;
5053 wxRect *arg1 = (wxRect *) 0 ;
5054 int arg2 ;
5055 PyObject * obj0 = 0 ;
5056 PyObject * obj1 = 0 ;
5057 char *kwnames[] = {
5058 (char *) "self",(char *) "y", NULL
5059 };
5060
5061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5063 if (SWIG_arg_fail(1)) SWIG_fail;
5064 {
5065 arg2 = (int)(SWIG_As_int(obj1));
5066 if (SWIG_arg_fail(2)) SWIG_fail;
5067 }
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 (arg1)->SetY(arg2);
5071
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 Py_INCREF(Py_None); resultobj = Py_None;
5076 return resultobj;
5077 fail:
5078 return NULL;
5079 }
5080
5081
5082 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5083 PyObject *resultobj;
5084 wxRect *arg1 = (wxRect *) 0 ;
5085 int result;
5086 PyObject * obj0 = 0 ;
5087 char *kwnames[] = {
5088 (char *) "self", NULL
5089 };
5090
5091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5093 if (SWIG_arg_fail(1)) SWIG_fail;
5094 {
5095 PyThreadState* __tstate = wxPyBeginAllowThreads();
5096 result = (int)((wxRect const *)arg1)->GetWidth();
5097
5098 wxPyEndAllowThreads(__tstate);
5099 if (PyErr_Occurred()) SWIG_fail;
5100 }
5101 {
5102 resultobj = SWIG_From_int((int)(result));
5103 }
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj;
5112 wxRect *arg1 = (wxRect *) 0 ;
5113 int arg2 ;
5114 PyObject * obj0 = 0 ;
5115 PyObject * obj1 = 0 ;
5116 char *kwnames[] = {
5117 (char *) "self",(char *) "w", NULL
5118 };
5119
5120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5122 if (SWIG_arg_fail(1)) SWIG_fail;
5123 {
5124 arg2 = (int)(SWIG_As_int(obj1));
5125 if (SWIG_arg_fail(2)) SWIG_fail;
5126 }
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 (arg1)->SetWidth(arg2);
5130
5131 wxPyEndAllowThreads(__tstate);
5132 if (PyErr_Occurred()) SWIG_fail;
5133 }
5134 Py_INCREF(Py_None); resultobj = Py_None;
5135 return resultobj;
5136 fail:
5137 return NULL;
5138 }
5139
5140
5141 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5142 PyObject *resultobj;
5143 wxRect *arg1 = (wxRect *) 0 ;
5144 int result;
5145 PyObject * obj0 = 0 ;
5146 char *kwnames[] = {
5147 (char *) "self", NULL
5148 };
5149
5150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5152 if (SWIG_arg_fail(1)) SWIG_fail;
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 result = (int)((wxRect const *)arg1)->GetHeight();
5156
5157 wxPyEndAllowThreads(__tstate);
5158 if (PyErr_Occurred()) SWIG_fail;
5159 }
5160 {
5161 resultobj = SWIG_From_int((int)(result));
5162 }
5163 return resultobj;
5164 fail:
5165 return NULL;
5166 }
5167
5168
5169 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5170 PyObject *resultobj;
5171 wxRect *arg1 = (wxRect *) 0 ;
5172 int arg2 ;
5173 PyObject * obj0 = 0 ;
5174 PyObject * obj1 = 0 ;
5175 char *kwnames[] = {
5176 (char *) "self",(char *) "h", NULL
5177 };
5178
5179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5181 if (SWIG_arg_fail(1)) SWIG_fail;
5182 {
5183 arg2 = (int)(SWIG_As_int(obj1));
5184 if (SWIG_arg_fail(2)) SWIG_fail;
5185 }
5186 {
5187 PyThreadState* __tstate = wxPyBeginAllowThreads();
5188 (arg1)->SetHeight(arg2);
5189
5190 wxPyEndAllowThreads(__tstate);
5191 if (PyErr_Occurred()) SWIG_fail;
5192 }
5193 Py_INCREF(Py_None); resultobj = Py_None;
5194 return resultobj;
5195 fail:
5196 return NULL;
5197 }
5198
5199
5200 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5201 PyObject *resultobj;
5202 wxRect *arg1 = (wxRect *) 0 ;
5203 wxPoint result;
5204 PyObject * obj0 = 0 ;
5205 char *kwnames[] = {
5206 (char *) "self", NULL
5207 };
5208
5209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5211 if (SWIG_arg_fail(1)) SWIG_fail;
5212 {
5213 PyThreadState* __tstate = wxPyBeginAllowThreads();
5214 result = ((wxRect const *)arg1)->GetPosition();
5215
5216 wxPyEndAllowThreads(__tstate);
5217 if (PyErr_Occurred()) SWIG_fail;
5218 }
5219 {
5220 wxPoint * resultptr;
5221 resultptr = new wxPoint((wxPoint &)(result));
5222 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5223 }
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5231 PyObject *resultobj;
5232 wxRect *arg1 = (wxRect *) 0 ;
5233 wxPoint *arg2 = 0 ;
5234 wxPoint temp2 ;
5235 PyObject * obj0 = 0 ;
5236 PyObject * obj1 = 0 ;
5237 char *kwnames[] = {
5238 (char *) "self",(char *) "p", NULL
5239 };
5240
5241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5243 if (SWIG_arg_fail(1)) SWIG_fail;
5244 {
5245 arg2 = &temp2;
5246 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5247 }
5248 {
5249 PyThreadState* __tstate = wxPyBeginAllowThreads();
5250 (arg1)->SetPosition((wxPoint const &)*arg2);
5251
5252 wxPyEndAllowThreads(__tstate);
5253 if (PyErr_Occurred()) SWIG_fail;
5254 }
5255 Py_INCREF(Py_None); resultobj = Py_None;
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5263 PyObject *resultobj;
5264 wxRect *arg1 = (wxRect *) 0 ;
5265 wxSize result;
5266 PyObject * obj0 = 0 ;
5267 char *kwnames[] = {
5268 (char *) "self", NULL
5269 };
5270
5271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5273 if (SWIG_arg_fail(1)) SWIG_fail;
5274 {
5275 PyThreadState* __tstate = wxPyBeginAllowThreads();
5276 result = ((wxRect const *)arg1)->GetSize();
5277
5278 wxPyEndAllowThreads(__tstate);
5279 if (PyErr_Occurred()) SWIG_fail;
5280 }
5281 {
5282 wxSize * resultptr;
5283 resultptr = new wxSize((wxSize &)(result));
5284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5285 }
5286 return resultobj;
5287 fail:
5288 return NULL;
5289 }
5290
5291
5292 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5293 PyObject *resultobj;
5294 wxRect *arg1 = (wxRect *) 0 ;
5295 wxSize *arg2 = 0 ;
5296 wxSize temp2 ;
5297 PyObject * obj0 = 0 ;
5298 PyObject * obj1 = 0 ;
5299 char *kwnames[] = {
5300 (char *) "self",(char *) "s", NULL
5301 };
5302
5303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5305 if (SWIG_arg_fail(1)) SWIG_fail;
5306 {
5307 arg2 = &temp2;
5308 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5309 }
5310 {
5311 PyThreadState* __tstate = wxPyBeginAllowThreads();
5312 (arg1)->SetSize((wxSize const &)*arg2);
5313
5314 wxPyEndAllowThreads(__tstate);
5315 if (PyErr_Occurred()) SWIG_fail;
5316 }
5317 Py_INCREF(Py_None); resultobj = Py_None;
5318 return resultobj;
5319 fail:
5320 return NULL;
5321 }
5322
5323
5324 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5325 PyObject *resultobj;
5326 wxRect *arg1 = (wxRect *) 0 ;
5327 bool result;
5328 PyObject * obj0 = 0 ;
5329 char *kwnames[] = {
5330 (char *) "self", NULL
5331 };
5332
5333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5335 if (SWIG_arg_fail(1)) SWIG_fail;
5336 {
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 result = (bool)((wxRect const *)arg1)->IsEmpty();
5339
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 {
5344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5345 }
5346 return resultobj;
5347 fail:
5348 return NULL;
5349 }
5350
5351
5352 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5353 PyObject *resultobj;
5354 wxRect *arg1 = (wxRect *) 0 ;
5355 wxPoint result;
5356 PyObject * obj0 = 0 ;
5357 char *kwnames[] = {
5358 (char *) "self", NULL
5359 };
5360
5361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5363 if (SWIG_arg_fail(1)) SWIG_fail;
5364 {
5365 PyThreadState* __tstate = wxPyBeginAllowThreads();
5366 result = ((wxRect const *)arg1)->GetTopLeft();
5367
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 {
5372 wxPoint * resultptr;
5373 resultptr = new wxPoint((wxPoint &)(result));
5374 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5375 }
5376 return resultobj;
5377 fail:
5378 return NULL;
5379 }
5380
5381
5382 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5383 PyObject *resultobj;
5384 wxRect *arg1 = (wxRect *) 0 ;
5385 wxPoint *arg2 = 0 ;
5386 wxPoint temp2 ;
5387 PyObject * obj0 = 0 ;
5388 PyObject * obj1 = 0 ;
5389 char *kwnames[] = {
5390 (char *) "self",(char *) "p", NULL
5391 };
5392
5393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5395 if (SWIG_arg_fail(1)) SWIG_fail;
5396 {
5397 arg2 = &temp2;
5398 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5399 }
5400 {
5401 PyThreadState* __tstate = wxPyBeginAllowThreads();
5402 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5403
5404 wxPyEndAllowThreads(__tstate);
5405 if (PyErr_Occurred()) SWIG_fail;
5406 }
5407 Py_INCREF(Py_None); resultobj = Py_None;
5408 return resultobj;
5409 fail:
5410 return NULL;
5411 }
5412
5413
5414 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5415 PyObject *resultobj;
5416 wxRect *arg1 = (wxRect *) 0 ;
5417 wxPoint result;
5418 PyObject * obj0 = 0 ;
5419 char *kwnames[] = {
5420 (char *) "self", NULL
5421 };
5422
5423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5425 if (SWIG_arg_fail(1)) SWIG_fail;
5426 {
5427 PyThreadState* __tstate = wxPyBeginAllowThreads();
5428 result = ((wxRect const *)arg1)->GetBottomRight();
5429
5430 wxPyEndAllowThreads(__tstate);
5431 if (PyErr_Occurred()) SWIG_fail;
5432 }
5433 {
5434 wxPoint * resultptr;
5435 resultptr = new wxPoint((wxPoint &)(result));
5436 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5437 }
5438 return resultobj;
5439 fail:
5440 return NULL;
5441 }
5442
5443
5444 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5445 PyObject *resultobj;
5446 wxRect *arg1 = (wxRect *) 0 ;
5447 wxPoint *arg2 = 0 ;
5448 wxPoint temp2 ;
5449 PyObject * obj0 = 0 ;
5450 PyObject * obj1 = 0 ;
5451 char *kwnames[] = {
5452 (char *) "self",(char *) "p", NULL
5453 };
5454
5455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5457 if (SWIG_arg_fail(1)) SWIG_fail;
5458 {
5459 arg2 = &temp2;
5460 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5461 }
5462 {
5463 PyThreadState* __tstate = wxPyBeginAllowThreads();
5464 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5465
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 Py_INCREF(Py_None); resultobj = Py_None;
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5477 PyObject *resultobj;
5478 wxRect *arg1 = (wxRect *) 0 ;
5479 int result;
5480 PyObject * obj0 = 0 ;
5481 char *kwnames[] = {
5482 (char *) "self", NULL
5483 };
5484
5485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5487 if (SWIG_arg_fail(1)) SWIG_fail;
5488 {
5489 PyThreadState* __tstate = wxPyBeginAllowThreads();
5490 result = (int)((wxRect const *)arg1)->GetLeft();
5491
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 {
5496 resultobj = SWIG_From_int((int)(result));
5497 }
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5505 PyObject *resultobj;
5506 wxRect *arg1 = (wxRect *) 0 ;
5507 int result;
5508 PyObject * obj0 = 0 ;
5509 char *kwnames[] = {
5510 (char *) "self", NULL
5511 };
5512
5513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5515 if (SWIG_arg_fail(1)) SWIG_fail;
5516 {
5517 PyThreadState* __tstate = wxPyBeginAllowThreads();
5518 result = (int)((wxRect const *)arg1)->GetTop();
5519
5520 wxPyEndAllowThreads(__tstate);
5521 if (PyErr_Occurred()) SWIG_fail;
5522 }
5523 {
5524 resultobj = SWIG_From_int((int)(result));
5525 }
5526 return resultobj;
5527 fail:
5528 return NULL;
5529 }
5530
5531
5532 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5533 PyObject *resultobj;
5534 wxRect *arg1 = (wxRect *) 0 ;
5535 int result;
5536 PyObject * obj0 = 0 ;
5537 char *kwnames[] = {
5538 (char *) "self", NULL
5539 };
5540
5541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5543 if (SWIG_arg_fail(1)) SWIG_fail;
5544 {
5545 PyThreadState* __tstate = wxPyBeginAllowThreads();
5546 result = (int)((wxRect const *)arg1)->GetBottom();
5547
5548 wxPyEndAllowThreads(__tstate);
5549 if (PyErr_Occurred()) SWIG_fail;
5550 }
5551 {
5552 resultobj = SWIG_From_int((int)(result));
5553 }
5554 return resultobj;
5555 fail:
5556 return NULL;
5557 }
5558
5559
5560 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5561 PyObject *resultobj;
5562 wxRect *arg1 = (wxRect *) 0 ;
5563 int result;
5564 PyObject * obj0 = 0 ;
5565 char *kwnames[] = {
5566 (char *) "self", NULL
5567 };
5568
5569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5571 if (SWIG_arg_fail(1)) SWIG_fail;
5572 {
5573 PyThreadState* __tstate = wxPyBeginAllowThreads();
5574 result = (int)((wxRect const *)arg1)->GetRight();
5575
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = SWIG_From_int((int)(result));
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj;
5590 wxRect *arg1 = (wxRect *) 0 ;
5591 int arg2 ;
5592 PyObject * obj0 = 0 ;
5593 PyObject * obj1 = 0 ;
5594 char *kwnames[] = {
5595 (char *) "self",(char *) "left", NULL
5596 };
5597
5598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5600 if (SWIG_arg_fail(1)) SWIG_fail;
5601 {
5602 arg2 = (int)(SWIG_As_int(obj1));
5603 if (SWIG_arg_fail(2)) SWIG_fail;
5604 }
5605 {
5606 PyThreadState* __tstate = wxPyBeginAllowThreads();
5607 (arg1)->SetLeft(arg2);
5608
5609 wxPyEndAllowThreads(__tstate);
5610 if (PyErr_Occurred()) SWIG_fail;
5611 }
5612 Py_INCREF(Py_None); resultobj = Py_None;
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5620 PyObject *resultobj;
5621 wxRect *arg1 = (wxRect *) 0 ;
5622 int arg2 ;
5623 PyObject * obj0 = 0 ;
5624 PyObject * obj1 = 0 ;
5625 char *kwnames[] = {
5626 (char *) "self",(char *) "right", NULL
5627 };
5628
5629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5631 if (SWIG_arg_fail(1)) SWIG_fail;
5632 {
5633 arg2 = (int)(SWIG_As_int(obj1));
5634 if (SWIG_arg_fail(2)) SWIG_fail;
5635 }
5636 {
5637 PyThreadState* __tstate = wxPyBeginAllowThreads();
5638 (arg1)->SetRight(arg2);
5639
5640 wxPyEndAllowThreads(__tstate);
5641 if (PyErr_Occurred()) SWIG_fail;
5642 }
5643 Py_INCREF(Py_None); resultobj = Py_None;
5644 return resultobj;
5645 fail:
5646 return NULL;
5647 }
5648
5649
5650 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5651 PyObject *resultobj;
5652 wxRect *arg1 = (wxRect *) 0 ;
5653 int arg2 ;
5654 PyObject * obj0 = 0 ;
5655 PyObject * obj1 = 0 ;
5656 char *kwnames[] = {
5657 (char *) "self",(char *) "top", NULL
5658 };
5659
5660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5662 if (SWIG_arg_fail(1)) SWIG_fail;
5663 {
5664 arg2 = (int)(SWIG_As_int(obj1));
5665 if (SWIG_arg_fail(2)) SWIG_fail;
5666 }
5667 {
5668 PyThreadState* __tstate = wxPyBeginAllowThreads();
5669 (arg1)->SetTop(arg2);
5670
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 Py_INCREF(Py_None); resultobj = Py_None;
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5682 PyObject *resultobj;
5683 wxRect *arg1 = (wxRect *) 0 ;
5684 int arg2 ;
5685 PyObject * obj0 = 0 ;
5686 PyObject * obj1 = 0 ;
5687 char *kwnames[] = {
5688 (char *) "self",(char *) "bottom", NULL
5689 };
5690
5691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5693 if (SWIG_arg_fail(1)) SWIG_fail;
5694 {
5695 arg2 = (int)(SWIG_As_int(obj1));
5696 if (SWIG_arg_fail(2)) SWIG_fail;
5697 }
5698 {
5699 PyThreadState* __tstate = wxPyBeginAllowThreads();
5700 (arg1)->SetBottom(arg2);
5701
5702 wxPyEndAllowThreads(__tstate);
5703 if (PyErr_Occurred()) SWIG_fail;
5704 }
5705 Py_INCREF(Py_None); resultobj = Py_None;
5706 return resultobj;
5707 fail:
5708 return NULL;
5709 }
5710
5711
5712 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5713 PyObject *resultobj;
5714 wxRect *arg1 = (wxRect *) 0 ;
5715 int arg2 ;
5716 int arg3 ;
5717 wxRect *result;
5718 PyObject * obj0 = 0 ;
5719 PyObject * obj1 = 0 ;
5720 PyObject * obj2 = 0 ;
5721 char *kwnames[] = {
5722 (char *) "self",(char *) "dx",(char *) "dy", NULL
5723 };
5724
5725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5727 if (SWIG_arg_fail(1)) SWIG_fail;
5728 {
5729 arg2 = (int)(SWIG_As_int(obj1));
5730 if (SWIG_arg_fail(2)) SWIG_fail;
5731 }
5732 {
5733 arg3 = (int)(SWIG_As_int(obj2));
5734 if (SWIG_arg_fail(3)) SWIG_fail;
5735 }
5736 {
5737 PyThreadState* __tstate = wxPyBeginAllowThreads();
5738 {
5739 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5740 result = (wxRect *) &_result_ref;
5741 }
5742
5743 wxPyEndAllowThreads(__tstate);
5744 if (PyErr_Occurred()) SWIG_fail;
5745 }
5746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5754 PyObject *resultobj;
5755 wxRect *arg1 = (wxRect *) 0 ;
5756 int arg2 ;
5757 int arg3 ;
5758 wxRect *result;
5759 PyObject * obj0 = 0 ;
5760 PyObject * obj1 = 0 ;
5761 PyObject * obj2 = 0 ;
5762 char *kwnames[] = {
5763 (char *) "self",(char *) "dx",(char *) "dy", NULL
5764 };
5765
5766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5768 if (SWIG_arg_fail(1)) SWIG_fail;
5769 {
5770 arg2 = (int)(SWIG_As_int(obj1));
5771 if (SWIG_arg_fail(2)) SWIG_fail;
5772 }
5773 {
5774 arg3 = (int)(SWIG_As_int(obj2));
5775 if (SWIG_arg_fail(3)) SWIG_fail;
5776 }
5777 {
5778 PyThreadState* __tstate = wxPyBeginAllowThreads();
5779 {
5780 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5781 result = (wxRect *) &_result_ref;
5782 }
5783
5784 wxPyEndAllowThreads(__tstate);
5785 if (PyErr_Occurred()) SWIG_fail;
5786 }
5787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5788 return resultobj;
5789 fail:
5790 return NULL;
5791 }
5792
5793
5794 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5795 PyObject *resultobj;
5796 wxRect *arg1 = (wxRect *) 0 ;
5797 int arg2 ;
5798 int arg3 ;
5799 PyObject * obj0 = 0 ;
5800 PyObject * obj1 = 0 ;
5801 PyObject * obj2 = 0 ;
5802 char *kwnames[] = {
5803 (char *) "self",(char *) "dx",(char *) "dy", NULL
5804 };
5805
5806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5808 if (SWIG_arg_fail(1)) SWIG_fail;
5809 {
5810 arg2 = (int)(SWIG_As_int(obj1));
5811 if (SWIG_arg_fail(2)) SWIG_fail;
5812 }
5813 {
5814 arg3 = (int)(SWIG_As_int(obj2));
5815 if (SWIG_arg_fail(3)) SWIG_fail;
5816 }
5817 {
5818 PyThreadState* __tstate = wxPyBeginAllowThreads();
5819 (arg1)->Offset(arg2,arg3);
5820
5821 wxPyEndAllowThreads(__tstate);
5822 if (PyErr_Occurred()) SWIG_fail;
5823 }
5824 Py_INCREF(Py_None); resultobj = Py_None;
5825 return resultobj;
5826 fail:
5827 return NULL;
5828 }
5829
5830
5831 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5832 PyObject *resultobj;
5833 wxRect *arg1 = (wxRect *) 0 ;
5834 wxPoint *arg2 = 0 ;
5835 wxPoint temp2 ;
5836 PyObject * obj0 = 0 ;
5837 PyObject * obj1 = 0 ;
5838 char *kwnames[] = {
5839 (char *) "self",(char *) "pt", NULL
5840 };
5841
5842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5844 if (SWIG_arg_fail(1)) SWIG_fail;
5845 {
5846 arg2 = &temp2;
5847 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5848 }
5849 {
5850 PyThreadState* __tstate = wxPyBeginAllowThreads();
5851 (arg1)->Offset((wxPoint const &)*arg2);
5852
5853 wxPyEndAllowThreads(__tstate);
5854 if (PyErr_Occurred()) SWIG_fail;
5855 }
5856 Py_INCREF(Py_None); resultobj = Py_None;
5857 return resultobj;
5858 fail:
5859 return NULL;
5860 }
5861
5862
5863 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5864 PyObject *resultobj;
5865 wxRect *arg1 = (wxRect *) 0 ;
5866 wxRect *arg2 = 0 ;
5867 wxRect result;
5868 wxRect temp2 ;
5869 PyObject * obj0 = 0 ;
5870 PyObject * obj1 = 0 ;
5871 char *kwnames[] = {
5872 (char *) "self",(char *) "rect", NULL
5873 };
5874
5875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5877 if (SWIG_arg_fail(1)) SWIG_fail;
5878 {
5879 arg2 = &temp2;
5880 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5881 }
5882 {
5883 PyThreadState* __tstate = wxPyBeginAllowThreads();
5884 result = (arg1)->Intersect((wxRect const &)*arg2);
5885
5886 wxPyEndAllowThreads(__tstate);
5887 if (PyErr_Occurred()) SWIG_fail;
5888 }
5889 {
5890 wxRect * resultptr;
5891 resultptr = new wxRect((wxRect &)(result));
5892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5893 }
5894 return resultobj;
5895 fail:
5896 return NULL;
5897 }
5898
5899
5900 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5901 PyObject *resultobj;
5902 wxRect *arg1 = (wxRect *) 0 ;
5903 wxRect *arg2 = 0 ;
5904 wxRect result;
5905 wxRect temp2 ;
5906 PyObject * obj0 = 0 ;
5907 PyObject * obj1 = 0 ;
5908 char *kwnames[] = {
5909 (char *) "self",(char *) "rect", NULL
5910 };
5911
5912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5914 if (SWIG_arg_fail(1)) SWIG_fail;
5915 {
5916 arg2 = &temp2;
5917 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5918 }
5919 {
5920 PyThreadState* __tstate = wxPyBeginAllowThreads();
5921 result = (arg1)->Union((wxRect const &)*arg2);
5922
5923 wxPyEndAllowThreads(__tstate);
5924 if (PyErr_Occurred()) SWIG_fail;
5925 }
5926 {
5927 wxRect * resultptr;
5928 resultptr = new wxRect((wxRect &)(result));
5929 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5930 }
5931 return resultobj;
5932 fail:
5933 return NULL;
5934 }
5935
5936
5937 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5938 PyObject *resultobj;
5939 wxRect *arg1 = (wxRect *) 0 ;
5940 wxRect *arg2 = 0 ;
5941 wxRect result;
5942 wxRect temp2 ;
5943 PyObject * obj0 = 0 ;
5944 PyObject * obj1 = 0 ;
5945 char *kwnames[] = {
5946 (char *) "self",(char *) "rect", NULL
5947 };
5948
5949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5951 if (SWIG_arg_fail(1)) SWIG_fail;
5952 {
5953 arg2 = &temp2;
5954 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5955 }
5956 {
5957 PyThreadState* __tstate = wxPyBeginAllowThreads();
5958 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5959
5960 wxPyEndAllowThreads(__tstate);
5961 if (PyErr_Occurred()) SWIG_fail;
5962 }
5963 {
5964 wxRect * resultptr;
5965 resultptr = new wxRect((wxRect &)(result));
5966 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5967 }
5968 return resultobj;
5969 fail:
5970 return NULL;
5971 }
5972
5973
5974 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5975 PyObject *resultobj;
5976 wxRect *arg1 = (wxRect *) 0 ;
5977 wxRect *arg2 = 0 ;
5978 wxRect *result;
5979 wxRect temp2 ;
5980 PyObject * obj0 = 0 ;
5981 PyObject * obj1 = 0 ;
5982 char *kwnames[] = {
5983 (char *) "self",(char *) "rect", NULL
5984 };
5985
5986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5988 if (SWIG_arg_fail(1)) SWIG_fail;
5989 {
5990 arg2 = &temp2;
5991 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5992 }
5993 {
5994 PyThreadState* __tstate = wxPyBeginAllowThreads();
5995 {
5996 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5997 result = (wxRect *) &_result_ref;
5998 }
5999
6000 wxPyEndAllowThreads(__tstate);
6001 if (PyErr_Occurred()) SWIG_fail;
6002 }
6003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6004 return resultobj;
6005 fail:
6006 return NULL;
6007 }
6008
6009
6010 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6011 PyObject *resultobj;
6012 wxRect *arg1 = (wxRect *) 0 ;
6013 wxRect *arg2 = 0 ;
6014 bool result;
6015 wxRect temp2 ;
6016 PyObject * obj0 = 0 ;
6017 PyObject * obj1 = 0 ;
6018 char *kwnames[] = {
6019 (char *) "self",(char *) "rect", NULL
6020 };
6021
6022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6024 if (SWIG_arg_fail(1)) SWIG_fail;
6025 {
6026 arg2 = &temp2;
6027 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6028 }
6029 {
6030 PyThreadState* __tstate = wxPyBeginAllowThreads();
6031 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6032
6033 wxPyEndAllowThreads(__tstate);
6034 if (PyErr_Occurred()) SWIG_fail;
6035 }
6036 {
6037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6038 }
6039 return resultobj;
6040 fail:
6041 return NULL;
6042 }
6043
6044
6045 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6046 PyObject *resultobj;
6047 wxRect *arg1 = (wxRect *) 0 ;
6048 wxRect *arg2 = 0 ;
6049 bool result;
6050 wxRect temp2 ;
6051 PyObject * obj0 = 0 ;
6052 PyObject * obj1 = 0 ;
6053 char *kwnames[] = {
6054 (char *) "self",(char *) "rect", NULL
6055 };
6056
6057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6059 if (SWIG_arg_fail(1)) SWIG_fail;
6060 {
6061 arg2 = &temp2;
6062 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6063 }
6064 {
6065 PyThreadState* __tstate = wxPyBeginAllowThreads();
6066 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6067
6068 wxPyEndAllowThreads(__tstate);
6069 if (PyErr_Occurred()) SWIG_fail;
6070 }
6071 {
6072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6073 }
6074 return resultobj;
6075 fail:
6076 return NULL;
6077 }
6078
6079
6080 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6081 PyObject *resultobj;
6082 wxRect *arg1 = (wxRect *) 0 ;
6083 int arg2 ;
6084 int arg3 ;
6085 bool result;
6086 PyObject * obj0 = 0 ;
6087 PyObject * obj1 = 0 ;
6088 PyObject * obj2 = 0 ;
6089 char *kwnames[] = {
6090 (char *) "self",(char *) "x",(char *) "y", NULL
6091 };
6092
6093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6095 if (SWIG_arg_fail(1)) SWIG_fail;
6096 {
6097 arg2 = (int)(SWIG_As_int(obj1));
6098 if (SWIG_arg_fail(2)) SWIG_fail;
6099 }
6100 {
6101 arg3 = (int)(SWIG_As_int(obj2));
6102 if (SWIG_arg_fail(3)) SWIG_fail;
6103 }
6104 {
6105 PyThreadState* __tstate = wxPyBeginAllowThreads();
6106 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6107
6108 wxPyEndAllowThreads(__tstate);
6109 if (PyErr_Occurred()) SWIG_fail;
6110 }
6111 {
6112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6113 }
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj;
6122 wxRect *arg1 = (wxRect *) 0 ;
6123 wxPoint *arg2 = 0 ;
6124 bool result;
6125 wxPoint temp2 ;
6126 PyObject * obj0 = 0 ;
6127 PyObject * obj1 = 0 ;
6128 char *kwnames[] = {
6129 (char *) "self",(char *) "pt", NULL
6130 };
6131
6132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6134 if (SWIG_arg_fail(1)) SWIG_fail;
6135 {
6136 arg2 = &temp2;
6137 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6142
6143 wxPyEndAllowThreads(__tstate);
6144 if (PyErr_Occurred()) SWIG_fail;
6145 }
6146 {
6147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6148 }
6149 return resultobj;
6150 fail:
6151 return NULL;
6152 }
6153
6154
6155 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6156 PyObject *resultobj;
6157 wxRect *arg1 = (wxRect *) 0 ;
6158 wxRect *arg2 = 0 ;
6159 bool result;
6160 wxRect temp2 ;
6161 PyObject * obj0 = 0 ;
6162 PyObject * obj1 = 0 ;
6163 char *kwnames[] = {
6164 (char *) "self",(char *) "rect", NULL
6165 };
6166
6167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6169 if (SWIG_arg_fail(1)) SWIG_fail;
6170 {
6171 arg2 = &temp2;
6172 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6173 }
6174 {
6175 PyThreadState* __tstate = wxPyBeginAllowThreads();
6176 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6177
6178 wxPyEndAllowThreads(__tstate);
6179 if (PyErr_Occurred()) SWIG_fail;
6180 }
6181 {
6182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6183 }
6184 return resultobj;
6185 fail:
6186 return NULL;
6187 }
6188
6189
6190 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6191 PyObject *resultobj;
6192 wxRect *arg1 = (wxRect *) 0 ;
6193 int arg2 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char *kwnames[] = {
6197 (char *) "self",(char *) "x", NULL
6198 };
6199
6200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6202 if (SWIG_arg_fail(1)) SWIG_fail;
6203 {
6204 arg2 = (int)(SWIG_As_int(obj1));
6205 if (SWIG_arg_fail(2)) SWIG_fail;
6206 }
6207 if (arg1) (arg1)->x = arg2;
6208
6209 Py_INCREF(Py_None); resultobj = Py_None;
6210 return resultobj;
6211 fail:
6212 return NULL;
6213 }
6214
6215
6216 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6217 PyObject *resultobj;
6218 wxRect *arg1 = (wxRect *) 0 ;
6219 int result;
6220 PyObject * obj0 = 0 ;
6221 char *kwnames[] = {
6222 (char *) "self", NULL
6223 };
6224
6225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6227 if (SWIG_arg_fail(1)) SWIG_fail;
6228 result = (int) ((arg1)->x);
6229
6230 {
6231 resultobj = SWIG_From_int((int)(result));
6232 }
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6240 PyObject *resultobj;
6241 wxRect *arg1 = (wxRect *) 0 ;
6242 int arg2 ;
6243 PyObject * obj0 = 0 ;
6244 PyObject * obj1 = 0 ;
6245 char *kwnames[] = {
6246 (char *) "self",(char *) "y", NULL
6247 };
6248
6249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6251 if (SWIG_arg_fail(1)) SWIG_fail;
6252 {
6253 arg2 = (int)(SWIG_As_int(obj1));
6254 if (SWIG_arg_fail(2)) SWIG_fail;
6255 }
6256 if (arg1) (arg1)->y = arg2;
6257
6258 Py_INCREF(Py_None); resultobj = Py_None;
6259 return resultobj;
6260 fail:
6261 return NULL;
6262 }
6263
6264
6265 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj;
6267 wxRect *arg1 = (wxRect *) 0 ;
6268 int result;
6269 PyObject * obj0 = 0 ;
6270 char *kwnames[] = {
6271 (char *) "self", NULL
6272 };
6273
6274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6276 if (SWIG_arg_fail(1)) SWIG_fail;
6277 result = (int) ((arg1)->y);
6278
6279 {
6280 resultobj = SWIG_From_int((int)(result));
6281 }
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj;
6290 wxRect *arg1 = (wxRect *) 0 ;
6291 int arg2 ;
6292 PyObject * obj0 = 0 ;
6293 PyObject * obj1 = 0 ;
6294 char *kwnames[] = {
6295 (char *) "self",(char *) "width", NULL
6296 };
6297
6298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6300 if (SWIG_arg_fail(1)) SWIG_fail;
6301 {
6302 arg2 = (int)(SWIG_As_int(obj1));
6303 if (SWIG_arg_fail(2)) SWIG_fail;
6304 }
6305 if (arg1) (arg1)->width = arg2;
6306
6307 Py_INCREF(Py_None); resultobj = Py_None;
6308 return resultobj;
6309 fail:
6310 return NULL;
6311 }
6312
6313
6314 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6315 PyObject *resultobj;
6316 wxRect *arg1 = (wxRect *) 0 ;
6317 int result;
6318 PyObject * obj0 = 0 ;
6319 char *kwnames[] = {
6320 (char *) "self", NULL
6321 };
6322
6323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6325 if (SWIG_arg_fail(1)) SWIG_fail;
6326 result = (int) ((arg1)->width);
6327
6328 {
6329 resultobj = SWIG_From_int((int)(result));
6330 }
6331 return resultobj;
6332 fail:
6333 return NULL;
6334 }
6335
6336
6337 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6338 PyObject *resultobj;
6339 wxRect *arg1 = (wxRect *) 0 ;
6340 int arg2 ;
6341 PyObject * obj0 = 0 ;
6342 PyObject * obj1 = 0 ;
6343 char *kwnames[] = {
6344 (char *) "self",(char *) "height", NULL
6345 };
6346
6347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) 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 {
6351 arg2 = (int)(SWIG_As_int(obj1));
6352 if (SWIG_arg_fail(2)) SWIG_fail;
6353 }
6354 if (arg1) (arg1)->height = arg2;
6355
6356 Py_INCREF(Py_None); resultobj = Py_None;
6357 return resultobj;
6358 fail:
6359 return NULL;
6360 }
6361
6362
6363 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6364 PyObject *resultobj;
6365 wxRect *arg1 = (wxRect *) 0 ;
6366 int result;
6367 PyObject * obj0 = 0 ;
6368 char *kwnames[] = {
6369 (char *) "self", NULL
6370 };
6371
6372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6374 if (SWIG_arg_fail(1)) SWIG_fail;
6375 result = (int) ((arg1)->height);
6376
6377 {
6378 resultobj = SWIG_From_int((int)(result));
6379 }
6380 return resultobj;
6381 fail:
6382 return NULL;
6383 }
6384
6385
6386 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6387 PyObject *resultobj;
6388 wxRect *arg1 = (wxRect *) 0 ;
6389 int arg2 = (int) 0 ;
6390 int arg3 = (int) 0 ;
6391 int arg4 = (int) 0 ;
6392 int arg5 = (int) 0 ;
6393 PyObject * obj0 = 0 ;
6394 PyObject * obj1 = 0 ;
6395 PyObject * obj2 = 0 ;
6396 PyObject * obj3 = 0 ;
6397 PyObject * obj4 = 0 ;
6398 char *kwnames[] = {
6399 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6400 };
6401
6402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6404 if (SWIG_arg_fail(1)) SWIG_fail;
6405 if (obj1) {
6406 {
6407 arg2 = (int)(SWIG_As_int(obj1));
6408 if (SWIG_arg_fail(2)) SWIG_fail;
6409 }
6410 }
6411 if (obj2) {
6412 {
6413 arg3 = (int)(SWIG_As_int(obj2));
6414 if (SWIG_arg_fail(3)) SWIG_fail;
6415 }
6416 }
6417 if (obj3) {
6418 {
6419 arg4 = (int)(SWIG_As_int(obj3));
6420 if (SWIG_arg_fail(4)) SWIG_fail;
6421 }
6422 }
6423 if (obj4) {
6424 {
6425 arg5 = (int)(SWIG_As_int(obj4));
6426 if (SWIG_arg_fail(5)) SWIG_fail;
6427 }
6428 }
6429 {
6430 PyThreadState* __tstate = wxPyBeginAllowThreads();
6431 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6432
6433 wxPyEndAllowThreads(__tstate);
6434 if (PyErr_Occurred()) SWIG_fail;
6435 }
6436 Py_INCREF(Py_None); resultobj = Py_None;
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6444 PyObject *resultobj;
6445 wxRect *arg1 = (wxRect *) 0 ;
6446 PyObject *result;
6447 PyObject * obj0 = 0 ;
6448 char *kwnames[] = {
6449 (char *) "self", NULL
6450 };
6451
6452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6454 if (SWIG_arg_fail(1)) SWIG_fail;
6455 {
6456 PyThreadState* __tstate = wxPyBeginAllowThreads();
6457 result = (PyObject *)wxRect_Get(arg1);
6458
6459 wxPyEndAllowThreads(__tstate);
6460 if (PyErr_Occurred()) SWIG_fail;
6461 }
6462 resultobj = result;
6463 return resultobj;
6464 fail:
6465 return NULL;
6466 }
6467
6468
6469 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6470 PyObject *obj;
6471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6472 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6473 Py_INCREF(obj);
6474 return Py_BuildValue((char *)"");
6475 }
6476 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6477 PyObject *resultobj;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 wxRect *arg2 = (wxRect *) 0 ;
6480 PyObject *result;
6481 PyObject * obj0 = 0 ;
6482 PyObject * obj1 = 0 ;
6483 char *kwnames[] = {
6484 (char *) "r1",(char *) "r2", NULL
6485 };
6486
6487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6489 if (SWIG_arg_fail(1)) SWIG_fail;
6490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6491 if (SWIG_arg_fail(2)) SWIG_fail;
6492 {
6493 if (!wxPyCheckForApp()) SWIG_fail;
6494 PyThreadState* __tstate = wxPyBeginAllowThreads();
6495 result = (PyObject *)wxIntersectRect(arg1,arg2);
6496
6497 wxPyEndAllowThreads(__tstate);
6498 if (PyErr_Occurred()) SWIG_fail;
6499 }
6500 resultobj = result;
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6508 PyObject *resultobj;
6509 double arg1 = (double) 0.0 ;
6510 double arg2 = (double) 0.0 ;
6511 wxPoint2D *result;
6512 PyObject * obj0 = 0 ;
6513 PyObject * obj1 = 0 ;
6514 char *kwnames[] = {
6515 (char *) "x",(char *) "y", NULL
6516 };
6517
6518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6519 if (obj0) {
6520 {
6521 arg1 = (double)(SWIG_As_double(obj0));
6522 if (SWIG_arg_fail(1)) SWIG_fail;
6523 }
6524 }
6525 if (obj1) {
6526 {
6527 arg2 = (double)(SWIG_As_double(obj1));
6528 if (SWIG_arg_fail(2)) SWIG_fail;
6529 }
6530 }
6531 {
6532 PyThreadState* __tstate = wxPyBeginAllowThreads();
6533 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6534
6535 wxPyEndAllowThreads(__tstate);
6536 if (PyErr_Occurred()) SWIG_fail;
6537 }
6538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6539 return resultobj;
6540 fail:
6541 return NULL;
6542 }
6543
6544
6545 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6546 PyObject *resultobj;
6547 wxPoint2D *arg1 = 0 ;
6548 wxPoint2D *result;
6549 wxPoint2D temp1 ;
6550 PyObject * obj0 = 0 ;
6551 char *kwnames[] = {
6552 (char *) "pt", NULL
6553 };
6554
6555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6556 {
6557 arg1 = &temp1;
6558 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6559 }
6560 {
6561 PyThreadState* __tstate = wxPyBeginAllowThreads();
6562 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6563
6564 wxPyEndAllowThreads(__tstate);
6565 if (PyErr_Occurred()) SWIG_fail;
6566 }
6567 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6575 PyObject *resultobj;
6576 wxPoint *arg1 = 0 ;
6577 wxPoint2D *result;
6578 wxPoint temp1 ;
6579 PyObject * obj0 = 0 ;
6580 char *kwnames[] = {
6581 (char *) "pt", NULL
6582 };
6583
6584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6585 {
6586 arg1 = &temp1;
6587 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6588 }
6589 {
6590 PyThreadState* __tstate = wxPyBeginAllowThreads();
6591 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6592
6593 wxPyEndAllowThreads(__tstate);
6594 if (PyErr_Occurred()) SWIG_fail;
6595 }
6596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6597 return resultobj;
6598 fail:
6599 return NULL;
6600 }
6601
6602
6603 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6604 PyObject *resultobj;
6605 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6606 int *arg2 = (int *) 0 ;
6607 int *arg3 = (int *) 0 ;
6608 int temp2 ;
6609 int res2 = 0 ;
6610 int temp3 ;
6611 int res3 = 0 ;
6612 PyObject * obj0 = 0 ;
6613 char *kwnames[] = {
6614 (char *) "self", NULL
6615 };
6616
6617 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6618 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6621 if (SWIG_arg_fail(1)) SWIG_fail;
6622 {
6623 PyThreadState* __tstate = wxPyBeginAllowThreads();
6624 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6625
6626 wxPyEndAllowThreads(__tstate);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 Py_INCREF(Py_None); resultobj = Py_None;
6630 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6631 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6632 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6633 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6634 return resultobj;
6635 fail:
6636 return NULL;
6637 }
6638
6639
6640 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6641 PyObject *resultobj;
6642 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6643 int *arg2 = (int *) 0 ;
6644 int *arg3 = (int *) 0 ;
6645 int temp2 ;
6646 int res2 = 0 ;
6647 int temp3 ;
6648 int res3 = 0 ;
6649 PyObject * obj0 = 0 ;
6650 char *kwnames[] = {
6651 (char *) "self", NULL
6652 };
6653
6654 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6655 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6658 if (SWIG_arg_fail(1)) SWIG_fail;
6659 {
6660 PyThreadState* __tstate = wxPyBeginAllowThreads();
6661 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6662
6663 wxPyEndAllowThreads(__tstate);
6664 if (PyErr_Occurred()) SWIG_fail;
6665 }
6666 Py_INCREF(Py_None); resultobj = Py_None;
6667 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6668 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6669 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6670 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6671 return resultobj;
6672 fail:
6673 return NULL;
6674 }
6675
6676
6677 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6678 PyObject *resultobj;
6679 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6680 double result;
6681 PyObject * obj0 = 0 ;
6682 char *kwnames[] = {
6683 (char *) "self", NULL
6684 };
6685
6686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6688 if (SWIG_arg_fail(1)) SWIG_fail;
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6692
6693 wxPyEndAllowThreads(__tstate);
6694 if (PyErr_Occurred()) SWIG_fail;
6695 }
6696 {
6697 resultobj = SWIG_From_double((double)(result));
6698 }
6699 return resultobj;
6700 fail:
6701 return NULL;
6702 }
6703
6704
6705 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6706 PyObject *resultobj;
6707 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6708 double result;
6709 PyObject * obj0 = 0 ;
6710 char *kwnames[] = {
6711 (char *) "self", NULL
6712 };
6713
6714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6716 if (SWIG_arg_fail(1)) SWIG_fail;
6717 {
6718 PyThreadState* __tstate = wxPyBeginAllowThreads();
6719 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6720
6721 wxPyEndAllowThreads(__tstate);
6722 if (PyErr_Occurred()) SWIG_fail;
6723 }
6724 {
6725 resultobj = SWIG_From_double((double)(result));
6726 }
6727 return resultobj;
6728 fail:
6729 return NULL;
6730 }
6731
6732
6733 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6734 PyObject *resultobj;
6735 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6736 double arg2 ;
6737 PyObject * obj0 = 0 ;
6738 PyObject * obj1 = 0 ;
6739 char *kwnames[] = {
6740 (char *) "self",(char *) "length", NULL
6741 };
6742
6743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6745 if (SWIG_arg_fail(1)) SWIG_fail;
6746 {
6747 arg2 = (double)(SWIG_As_double(obj1));
6748 if (SWIG_arg_fail(2)) SWIG_fail;
6749 }
6750 {
6751 PyThreadState* __tstate = wxPyBeginAllowThreads();
6752 (arg1)->SetVectorLength(arg2);
6753
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 Py_INCREF(Py_None); resultobj = Py_None;
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6765 PyObject *resultobj;
6766 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6767 double arg2 ;
6768 PyObject * obj0 = 0 ;
6769 PyObject * obj1 = 0 ;
6770 char *kwnames[] = {
6771 (char *) "self",(char *) "degrees", NULL
6772 };
6773
6774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6776 if (SWIG_arg_fail(1)) SWIG_fail;
6777 {
6778 arg2 = (double)(SWIG_As_double(obj1));
6779 if (SWIG_arg_fail(2)) SWIG_fail;
6780 }
6781 {
6782 PyThreadState* __tstate = wxPyBeginAllowThreads();
6783 (arg1)->SetVectorAngle(arg2);
6784
6785 wxPyEndAllowThreads(__tstate);
6786 if (PyErr_Occurred()) SWIG_fail;
6787 }
6788 Py_INCREF(Py_None); resultobj = Py_None;
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6796 PyObject *resultobj;
6797 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6798 wxPoint2D *arg2 = 0 ;
6799 double result;
6800 wxPoint2D temp2 ;
6801 PyObject * obj0 = 0 ;
6802 PyObject * obj1 = 0 ;
6803 char *kwnames[] = {
6804 (char *) "self",(char *) "pt", NULL
6805 };
6806
6807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6809 if (SWIG_arg_fail(1)) SWIG_fail;
6810 {
6811 arg2 = &temp2;
6812 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6813 }
6814 {
6815 PyThreadState* __tstate = wxPyBeginAllowThreads();
6816 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6817
6818 wxPyEndAllowThreads(__tstate);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 {
6822 resultobj = SWIG_From_double((double)(result));
6823 }
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6831 PyObject *resultobj;
6832 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6833 wxPoint2D *arg2 = 0 ;
6834 double result;
6835 wxPoint2D temp2 ;
6836 PyObject * obj0 = 0 ;
6837 PyObject * obj1 = 0 ;
6838 char *kwnames[] = {
6839 (char *) "self",(char *) "pt", NULL
6840 };
6841
6842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6844 if (SWIG_arg_fail(1)) SWIG_fail;
6845 {
6846 arg2 = &temp2;
6847 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6848 }
6849 {
6850 PyThreadState* __tstate = wxPyBeginAllowThreads();
6851 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6852
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 {
6857 resultobj = SWIG_From_double((double)(result));
6858 }
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6866 PyObject *resultobj;
6867 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6868 wxPoint2D *arg2 = 0 ;
6869 double result;
6870 wxPoint2D temp2 ;
6871 PyObject * obj0 = 0 ;
6872 PyObject * obj1 = 0 ;
6873 char *kwnames[] = {
6874 (char *) "self",(char *) "vec", NULL
6875 };
6876
6877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6879 if (SWIG_arg_fail(1)) SWIG_fail;
6880 {
6881 arg2 = &temp2;
6882 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6883 }
6884 {
6885 PyThreadState* __tstate = wxPyBeginAllowThreads();
6886 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6887
6888 wxPyEndAllowThreads(__tstate);
6889 if (PyErr_Occurred()) SWIG_fail;
6890 }
6891 {
6892 resultobj = SWIG_From_double((double)(result));
6893 }
6894 return resultobj;
6895 fail:
6896 return NULL;
6897 }
6898
6899
6900 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6901 PyObject *resultobj;
6902 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6903 wxPoint2D *arg2 = 0 ;
6904 double result;
6905 wxPoint2D temp2 ;
6906 PyObject * obj0 = 0 ;
6907 PyObject * obj1 = 0 ;
6908 char *kwnames[] = {
6909 (char *) "self",(char *) "vec", NULL
6910 };
6911
6912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6914 if (SWIG_arg_fail(1)) SWIG_fail;
6915 {
6916 arg2 = &temp2;
6917 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6918 }
6919 {
6920 PyThreadState* __tstate = wxPyBeginAllowThreads();
6921 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6922
6923 wxPyEndAllowThreads(__tstate);
6924 if (PyErr_Occurred()) SWIG_fail;
6925 }
6926 {
6927 resultobj = SWIG_From_double((double)(result));
6928 }
6929 return resultobj;
6930 fail:
6931 return NULL;
6932 }
6933
6934
6935 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6936 PyObject *resultobj;
6937 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6938 wxPoint2D result;
6939 PyObject * obj0 = 0 ;
6940 char *kwnames[] = {
6941 (char *) "self", NULL
6942 };
6943
6944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6946 if (SWIG_arg_fail(1)) SWIG_fail;
6947 {
6948 PyThreadState* __tstate = wxPyBeginAllowThreads();
6949 result = (arg1)->operator -();
6950
6951 wxPyEndAllowThreads(__tstate);
6952 if (PyErr_Occurred()) SWIG_fail;
6953 }
6954 {
6955 wxPoint2D * resultptr;
6956 resultptr = new wxPoint2D((wxPoint2D &)(result));
6957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6958 }
6959 return resultobj;
6960 fail:
6961 return NULL;
6962 }
6963
6964
6965 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6966 PyObject *resultobj;
6967 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6968 wxPoint2D *arg2 = 0 ;
6969 wxPoint2D *result;
6970 wxPoint2D temp2 ;
6971 PyObject * obj0 = 0 ;
6972 PyObject * obj1 = 0 ;
6973 char *kwnames[] = {
6974 (char *) "self",(char *) "pt", NULL
6975 };
6976
6977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6979 if (SWIG_arg_fail(1)) SWIG_fail;
6980 {
6981 arg2 = &temp2;
6982 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6983 }
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 {
6987 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6988 result = (wxPoint2D *) &_result_ref;
6989 }
6990
6991 wxPyEndAllowThreads(__tstate);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7002 PyObject *resultobj;
7003 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7004 wxPoint2D *arg2 = 0 ;
7005 wxPoint2D *result;
7006 wxPoint2D temp2 ;
7007 PyObject * obj0 = 0 ;
7008 PyObject * obj1 = 0 ;
7009 char *kwnames[] = {
7010 (char *) "self",(char *) "pt", NULL
7011 };
7012
7013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7015 if (SWIG_arg_fail(1)) SWIG_fail;
7016 {
7017 arg2 = &temp2;
7018 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7019 }
7020 {
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 {
7023 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7024 result = (wxPoint2D *) &_result_ref;
7025 }
7026
7027 wxPyEndAllowThreads(__tstate);
7028 if (PyErr_Occurred()) SWIG_fail;
7029 }
7030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7031 return resultobj;
7032 fail:
7033 return NULL;
7034 }
7035
7036
7037 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7038 PyObject *resultobj;
7039 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7040 wxPoint2D *arg2 = 0 ;
7041 wxPoint2D *result;
7042 wxPoint2D temp2 ;
7043 PyObject * obj0 = 0 ;
7044 PyObject * obj1 = 0 ;
7045 char *kwnames[] = {
7046 (char *) "self",(char *) "pt", NULL
7047 };
7048
7049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7051 if (SWIG_arg_fail(1)) SWIG_fail;
7052 {
7053 arg2 = &temp2;
7054 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7055 }
7056 {
7057 PyThreadState* __tstate = wxPyBeginAllowThreads();
7058 {
7059 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7060 result = (wxPoint2D *) &_result_ref;
7061 }
7062
7063 wxPyEndAllowThreads(__tstate);
7064 if (PyErr_Occurred()) SWIG_fail;
7065 }
7066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7067 return resultobj;
7068 fail:
7069 return NULL;
7070 }
7071
7072
7073 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7074 PyObject *resultobj;
7075 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7076 wxPoint2D *arg2 = 0 ;
7077 wxPoint2D *result;
7078 wxPoint2D temp2 ;
7079 PyObject * obj0 = 0 ;
7080 PyObject * obj1 = 0 ;
7081 char *kwnames[] = {
7082 (char *) "self",(char *) "pt", NULL
7083 };
7084
7085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7087 if (SWIG_arg_fail(1)) SWIG_fail;
7088 {
7089 arg2 = &temp2;
7090 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7091 }
7092 {
7093 PyThreadState* __tstate = wxPyBeginAllowThreads();
7094 {
7095 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7096 result = (wxPoint2D *) &_result_ref;
7097 }
7098
7099 wxPyEndAllowThreads(__tstate);
7100 if (PyErr_Occurred()) SWIG_fail;
7101 }
7102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7103 return resultobj;
7104 fail:
7105 return NULL;
7106 }
7107
7108
7109 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7110 PyObject *resultobj;
7111 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7112 wxPoint2D *arg2 = 0 ;
7113 bool result;
7114 wxPoint2D temp2 ;
7115 PyObject * obj0 = 0 ;
7116 PyObject * obj1 = 0 ;
7117 char *kwnames[] = {
7118 (char *) "self",(char *) "pt", NULL
7119 };
7120
7121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7123 if (SWIG_arg_fail(1)) SWIG_fail;
7124 {
7125 arg2 = &temp2;
7126 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7127 }
7128 {
7129 PyThreadState* __tstate = wxPyBeginAllowThreads();
7130 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7131
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 {
7136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj;
7146 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7147 wxPoint2D *arg2 = 0 ;
7148 bool result;
7149 wxPoint2D temp2 ;
7150 PyObject * obj0 = 0 ;
7151 PyObject * obj1 = 0 ;
7152 char *kwnames[] = {
7153 (char *) "self",(char *) "pt", NULL
7154 };
7155
7156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7158 if (SWIG_arg_fail(1)) SWIG_fail;
7159 {
7160 arg2 = &temp2;
7161 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7162 }
7163 {
7164 PyThreadState* __tstate = wxPyBeginAllowThreads();
7165 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7166
7167 wxPyEndAllowThreads(__tstate);
7168 if (PyErr_Occurred()) SWIG_fail;
7169 }
7170 {
7171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7172 }
7173 return resultobj;
7174 fail:
7175 return NULL;
7176 }
7177
7178
7179 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7180 PyObject *resultobj;
7181 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7182 double arg2 ;
7183 PyObject * obj0 = 0 ;
7184 PyObject * obj1 = 0 ;
7185 char *kwnames[] = {
7186 (char *) "self",(char *) "m_x", NULL
7187 };
7188
7189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7191 if (SWIG_arg_fail(1)) SWIG_fail;
7192 {
7193 arg2 = (double)(SWIG_As_double(obj1));
7194 if (SWIG_arg_fail(2)) SWIG_fail;
7195 }
7196 if (arg1) (arg1)->m_x = arg2;
7197
7198 Py_INCREF(Py_None); resultobj = Py_None;
7199 return resultobj;
7200 fail:
7201 return NULL;
7202 }
7203
7204
7205 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7206 PyObject *resultobj;
7207 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7208 double result;
7209 PyObject * obj0 = 0 ;
7210 char *kwnames[] = {
7211 (char *) "self", NULL
7212 };
7213
7214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7216 if (SWIG_arg_fail(1)) SWIG_fail;
7217 result = (double) ((arg1)->m_x);
7218
7219 {
7220 resultobj = SWIG_From_double((double)(result));
7221 }
7222 return resultobj;
7223 fail:
7224 return NULL;
7225 }
7226
7227
7228 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7229 PyObject *resultobj;
7230 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7231 double arg2 ;
7232 PyObject * obj0 = 0 ;
7233 PyObject * obj1 = 0 ;
7234 char *kwnames[] = {
7235 (char *) "self",(char *) "m_y", NULL
7236 };
7237
7238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7240 if (SWIG_arg_fail(1)) SWIG_fail;
7241 {
7242 arg2 = (double)(SWIG_As_double(obj1));
7243 if (SWIG_arg_fail(2)) SWIG_fail;
7244 }
7245 if (arg1) (arg1)->m_y = arg2;
7246
7247 Py_INCREF(Py_None); resultobj = Py_None;
7248 return resultobj;
7249 fail:
7250 return NULL;
7251 }
7252
7253
7254 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7255 PyObject *resultobj;
7256 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7257 double result;
7258 PyObject * obj0 = 0 ;
7259 char *kwnames[] = {
7260 (char *) "self", NULL
7261 };
7262
7263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7265 if (SWIG_arg_fail(1)) SWIG_fail;
7266 result = (double) ((arg1)->m_y);
7267
7268 {
7269 resultobj = SWIG_From_double((double)(result));
7270 }
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj;
7279 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7280 double arg2 = (double) 0 ;
7281 double arg3 = (double) 0 ;
7282 PyObject * obj0 = 0 ;
7283 PyObject * obj1 = 0 ;
7284 PyObject * obj2 = 0 ;
7285 char *kwnames[] = {
7286 (char *) "self",(char *) "x",(char *) "y", NULL
7287 };
7288
7289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7291 if (SWIG_arg_fail(1)) SWIG_fail;
7292 if (obj1) {
7293 {
7294 arg2 = (double)(SWIG_As_double(obj1));
7295 if (SWIG_arg_fail(2)) SWIG_fail;
7296 }
7297 }
7298 if (obj2) {
7299 {
7300 arg3 = (double)(SWIG_As_double(obj2));
7301 if (SWIG_arg_fail(3)) SWIG_fail;
7302 }
7303 }
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 wxPoint2D_Set(arg1,arg2,arg3);
7307
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 Py_INCREF(Py_None); resultobj = Py_None;
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7319 PyObject *resultobj;
7320 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7321 PyObject *result;
7322 PyObject * obj0 = 0 ;
7323 char *kwnames[] = {
7324 (char *) "self", NULL
7325 };
7326
7327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7329 if (SWIG_arg_fail(1)) SWIG_fail;
7330 {
7331 PyThreadState* __tstate = wxPyBeginAllowThreads();
7332 result = (PyObject *)wxPoint2D_Get(arg1);
7333
7334 wxPyEndAllowThreads(__tstate);
7335 if (PyErr_Occurred()) SWIG_fail;
7336 }
7337 resultobj = result;
7338 return resultobj;
7339 fail:
7340 return NULL;
7341 }
7342
7343
7344 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7345 PyObject *obj;
7346 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7347 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7348 Py_INCREF(obj);
7349 return Py_BuildValue((char *)"");
7350 }
7351 static int _wrap_DefaultPosition_set(PyObject *) {
7352 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7353 return 1;
7354 }
7355
7356
7357 static PyObject *_wrap_DefaultPosition_get(void) {
7358 PyObject *pyobj;
7359
7360 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7361 return pyobj;
7362 }
7363
7364
7365 static int _wrap_DefaultSize_set(PyObject *) {
7366 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7367 return 1;
7368 }
7369
7370
7371 static PyObject *_wrap_DefaultSize_get(void) {
7372 PyObject *pyobj;
7373
7374 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7375 return pyobj;
7376 }
7377
7378
7379 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7380 PyObject *resultobj;
7381 PyObject *arg1 = (PyObject *) 0 ;
7382 wxPyInputStream *result;
7383 PyObject * obj0 = 0 ;
7384 char *kwnames[] = {
7385 (char *) "p", NULL
7386 };
7387
7388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7389 arg1 = obj0;
7390 {
7391 PyThreadState* __tstate = wxPyBeginAllowThreads();
7392 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7393
7394 wxPyEndAllowThreads(__tstate);
7395 if (PyErr_Occurred()) SWIG_fail;
7396 }
7397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7398 return resultobj;
7399 fail:
7400 return NULL;
7401 }
7402
7403
7404 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7405 PyObject *resultobj;
7406 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7407 PyObject * obj0 = 0 ;
7408 char *kwnames[] = {
7409 (char *) "self", NULL
7410 };
7411
7412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7414 if (SWIG_arg_fail(1)) SWIG_fail;
7415 {
7416 PyThreadState* __tstate = wxPyBeginAllowThreads();
7417 delete arg1;
7418
7419 wxPyEndAllowThreads(__tstate);
7420 if (PyErr_Occurred()) SWIG_fail;
7421 }
7422 Py_INCREF(Py_None); resultobj = Py_None;
7423 return resultobj;
7424 fail:
7425 return NULL;
7426 }
7427
7428
7429 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7430 PyObject *resultobj;
7431 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7432 PyObject * obj0 = 0 ;
7433 char *kwnames[] = {
7434 (char *) "self", NULL
7435 };
7436
7437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7439 if (SWIG_arg_fail(1)) SWIG_fail;
7440 {
7441 PyThreadState* __tstate = wxPyBeginAllowThreads();
7442 (arg1)->close();
7443
7444 wxPyEndAllowThreads(__tstate);
7445 if (PyErr_Occurred()) SWIG_fail;
7446 }
7447 Py_INCREF(Py_None); resultobj = Py_None;
7448 return resultobj;
7449 fail:
7450 return NULL;
7451 }
7452
7453
7454 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7455 PyObject *resultobj;
7456 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7457 PyObject * obj0 = 0 ;
7458 char *kwnames[] = {
7459 (char *) "self", NULL
7460 };
7461
7462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7464 if (SWIG_arg_fail(1)) SWIG_fail;
7465 {
7466 PyThreadState* __tstate = wxPyBeginAllowThreads();
7467 (arg1)->flush();
7468
7469 wxPyEndAllowThreads(__tstate);
7470 if (PyErr_Occurred()) SWIG_fail;
7471 }
7472 Py_INCREF(Py_None); resultobj = Py_None;
7473 return resultobj;
7474 fail:
7475 return NULL;
7476 }
7477
7478
7479 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7480 PyObject *resultobj;
7481 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7482 bool result;
7483 PyObject * obj0 = 0 ;
7484 char *kwnames[] = {
7485 (char *) "self", NULL
7486 };
7487
7488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7490 if (SWIG_arg_fail(1)) SWIG_fail;
7491 {
7492 PyThreadState* __tstate = wxPyBeginAllowThreads();
7493 result = (bool)(arg1)->eof();
7494
7495 wxPyEndAllowThreads(__tstate);
7496 if (PyErr_Occurred()) SWIG_fail;
7497 }
7498 {
7499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7500 }
7501 return resultobj;
7502 fail:
7503 return NULL;
7504 }
7505
7506
7507 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7508 PyObject *resultobj;
7509 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7510 int arg2 = (int) -1 ;
7511 PyObject *result;
7512 PyObject * obj0 = 0 ;
7513 PyObject * obj1 = 0 ;
7514 char *kwnames[] = {
7515 (char *) "self",(char *) "size", NULL
7516 };
7517
7518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7520 if (SWIG_arg_fail(1)) SWIG_fail;
7521 if (obj1) {
7522 {
7523 arg2 = (int)(SWIG_As_int(obj1));
7524 if (SWIG_arg_fail(2)) SWIG_fail;
7525 }
7526 }
7527 {
7528 PyThreadState* __tstate = wxPyBeginAllowThreads();
7529 result = (PyObject *)(arg1)->read(arg2);
7530
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 resultobj = result;
7535 return resultobj;
7536 fail:
7537 return NULL;
7538 }
7539
7540
7541 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7542 PyObject *resultobj;
7543 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7544 int arg2 = (int) -1 ;
7545 PyObject *result;
7546 PyObject * obj0 = 0 ;
7547 PyObject * obj1 = 0 ;
7548 char *kwnames[] = {
7549 (char *) "self",(char *) "size", NULL
7550 };
7551
7552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7554 if (SWIG_arg_fail(1)) SWIG_fail;
7555 if (obj1) {
7556 {
7557 arg2 = (int)(SWIG_As_int(obj1));
7558 if (SWIG_arg_fail(2)) SWIG_fail;
7559 }
7560 }
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 result = (PyObject *)(arg1)->readline(arg2);
7564
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 resultobj = result;
7569 return resultobj;
7570 fail:
7571 return NULL;
7572 }
7573
7574
7575 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7576 PyObject *resultobj;
7577 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7578 int arg2 = (int) -1 ;
7579 PyObject *result;
7580 PyObject * obj0 = 0 ;
7581 PyObject * obj1 = 0 ;
7582 char *kwnames[] = {
7583 (char *) "self",(char *) "sizehint", NULL
7584 };
7585
7586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7588 if (SWIG_arg_fail(1)) SWIG_fail;
7589 if (obj1) {
7590 {
7591 arg2 = (int)(SWIG_As_int(obj1));
7592 if (SWIG_arg_fail(2)) SWIG_fail;
7593 }
7594 }
7595 {
7596 PyThreadState* __tstate = wxPyBeginAllowThreads();
7597 result = (PyObject *)(arg1)->readlines(arg2);
7598
7599 wxPyEndAllowThreads(__tstate);
7600 if (PyErr_Occurred()) SWIG_fail;
7601 }
7602 resultobj = result;
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj;
7611 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7612 int arg2 ;
7613 int arg3 = (int) 0 ;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 PyObject * obj2 = 0 ;
7617 char *kwnames[] = {
7618 (char *) "self",(char *) "offset",(char *) "whence", NULL
7619 };
7620
7621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7623 if (SWIG_arg_fail(1)) SWIG_fail;
7624 {
7625 arg2 = (int)(SWIG_As_int(obj1));
7626 if (SWIG_arg_fail(2)) SWIG_fail;
7627 }
7628 if (obj2) {
7629 {
7630 arg3 = (int)(SWIG_As_int(obj2));
7631 if (SWIG_arg_fail(3)) SWIG_fail;
7632 }
7633 }
7634 {
7635 PyThreadState* __tstate = wxPyBeginAllowThreads();
7636 (arg1)->seek(arg2,arg3);
7637
7638 wxPyEndAllowThreads(__tstate);
7639 if (PyErr_Occurred()) SWIG_fail;
7640 }
7641 Py_INCREF(Py_None); resultobj = Py_None;
7642 return resultobj;
7643 fail:
7644 return NULL;
7645 }
7646
7647
7648 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7649 PyObject *resultobj;
7650 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7651 int result;
7652 PyObject * obj0 = 0 ;
7653 char *kwnames[] = {
7654 (char *) "self", NULL
7655 };
7656
7657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7659 if (SWIG_arg_fail(1)) SWIG_fail;
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 result = (int)(arg1)->tell();
7663
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 {
7668 resultobj = SWIG_From_int((int)(result));
7669 }
7670 return resultobj;
7671 fail:
7672 return NULL;
7673 }
7674
7675
7676 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7677 PyObject *resultobj;
7678 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7679 char result;
7680 PyObject * obj0 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "self", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7687 if (SWIG_arg_fail(1)) SWIG_fail;
7688 {
7689 PyThreadState* __tstate = wxPyBeginAllowThreads();
7690 result = (char)(arg1)->Peek();
7691
7692 wxPyEndAllowThreads(__tstate);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 {
7696 resultobj = SWIG_From_char((char)(result));
7697 }
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj;
7706 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7707 char result;
7708 PyObject * obj0 = 0 ;
7709 char *kwnames[] = {
7710 (char *) "self", NULL
7711 };
7712
7713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7715 if (SWIG_arg_fail(1)) SWIG_fail;
7716 {
7717 PyThreadState* __tstate = wxPyBeginAllowThreads();
7718 result = (char)(arg1)->GetC();
7719
7720 wxPyEndAllowThreads(__tstate);
7721 if (PyErr_Occurred()) SWIG_fail;
7722 }
7723 {
7724 resultobj = SWIG_From_char((char)(result));
7725 }
7726 return resultobj;
7727 fail:
7728 return NULL;
7729 }
7730
7731
7732 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7733 PyObject *resultobj;
7734 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7735 size_t result;
7736 PyObject * obj0 = 0 ;
7737 char *kwnames[] = {
7738 (char *) "self", NULL
7739 };
7740
7741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7743 if (SWIG_arg_fail(1)) SWIG_fail;
7744 {
7745 PyThreadState* __tstate = wxPyBeginAllowThreads();
7746 result = (size_t)(arg1)->LastRead();
7747
7748 wxPyEndAllowThreads(__tstate);
7749 if (PyErr_Occurred()) SWIG_fail;
7750 }
7751 {
7752 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7753 }
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7761 PyObject *resultobj;
7762 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7763 bool result;
7764 PyObject * obj0 = 0 ;
7765 char *kwnames[] = {
7766 (char *) "self", NULL
7767 };
7768
7769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7771 if (SWIG_arg_fail(1)) SWIG_fail;
7772 {
7773 PyThreadState* __tstate = wxPyBeginAllowThreads();
7774 result = (bool)(arg1)->CanRead();
7775
7776 wxPyEndAllowThreads(__tstate);
7777 if (PyErr_Occurred()) SWIG_fail;
7778 }
7779 {
7780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7781 }
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj;
7790 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7791 bool result;
7792 PyObject * obj0 = 0 ;
7793 char *kwnames[] = {
7794 (char *) "self", NULL
7795 };
7796
7797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7799 if (SWIG_arg_fail(1)) SWIG_fail;
7800 {
7801 PyThreadState* __tstate = wxPyBeginAllowThreads();
7802 result = (bool)(arg1)->Eof();
7803
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 {
7808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7809 }
7810 return resultobj;
7811 fail:
7812 return NULL;
7813 }
7814
7815
7816 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7817 PyObject *resultobj;
7818 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7819 char arg2 ;
7820 bool result;
7821 PyObject * obj0 = 0 ;
7822 PyObject * obj1 = 0 ;
7823 char *kwnames[] = {
7824 (char *) "self",(char *) "c", NULL
7825 };
7826
7827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7829 if (SWIG_arg_fail(1)) SWIG_fail;
7830 {
7831 arg2 = (char)(SWIG_As_char(obj1));
7832 if (SWIG_arg_fail(2)) SWIG_fail;
7833 }
7834 {
7835 PyThreadState* __tstate = wxPyBeginAllowThreads();
7836 result = (bool)(arg1)->Ungetch(arg2);
7837
7838 wxPyEndAllowThreads(__tstate);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 {
7842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7843 }
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj;
7852 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7853 long arg2 ;
7854 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7855 long result;
7856 PyObject * obj0 = 0 ;
7857 PyObject * obj1 = 0 ;
7858 PyObject * obj2 = 0 ;
7859 char *kwnames[] = {
7860 (char *) "self",(char *) "pos",(char *) "mode", NULL
7861 };
7862
7863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7865 if (SWIG_arg_fail(1)) SWIG_fail;
7866 {
7867 arg2 = (long)(SWIG_As_long(obj1));
7868 if (SWIG_arg_fail(2)) SWIG_fail;
7869 }
7870 if (obj2) {
7871 {
7872 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7873 if (SWIG_arg_fail(3)) SWIG_fail;
7874 }
7875 }
7876 {
7877 PyThreadState* __tstate = wxPyBeginAllowThreads();
7878 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7879
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 {
7884 resultobj = SWIG_From_long((long)(result));
7885 }
7886 return resultobj;
7887 fail:
7888 return NULL;
7889 }
7890
7891
7892 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7893 PyObject *resultobj;
7894 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7895 long result;
7896 PyObject * obj0 = 0 ;
7897 char *kwnames[] = {
7898 (char *) "self", NULL
7899 };
7900
7901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7903 if (SWIG_arg_fail(1)) SWIG_fail;
7904 {
7905 PyThreadState* __tstate = wxPyBeginAllowThreads();
7906 result = (long)(arg1)->TellI();
7907
7908 wxPyEndAllowThreads(__tstate);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 {
7912 resultobj = SWIG_From_long((long)(result));
7913 }
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7921 PyObject *obj;
7922 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7923 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7924 Py_INCREF(obj);
7925 return Py_BuildValue((char *)"");
7926 }
7927 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7928 PyObject *resultobj;
7929 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7930 PyObject *arg2 = (PyObject *) 0 ;
7931 PyObject * obj0 = 0 ;
7932 PyObject * obj1 = 0 ;
7933 char *kwnames[] = {
7934 (char *) "self",(char *) "obj", NULL
7935 };
7936
7937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7939 if (SWIG_arg_fail(1)) SWIG_fail;
7940 arg2 = obj1;
7941 {
7942 PyThreadState* __tstate = wxPyBeginAllowThreads();
7943 wxOutputStream_write(arg1,arg2);
7944
7945 wxPyEndAllowThreads(__tstate);
7946 if (PyErr_Occurred()) SWIG_fail;
7947 }
7948 Py_INCREF(Py_None); resultobj = Py_None;
7949 return resultobj;
7950 fail:
7951 return NULL;
7952 }
7953
7954
7955 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7956 PyObject *obj;
7957 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7958 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7959 Py_INCREF(obj);
7960 return Py_BuildValue((char *)"");
7961 }
7962 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7963 PyObject *resultobj;
7964 wxInputStream *arg1 = (wxInputStream *) 0 ;
7965 wxString *arg2 = 0 ;
7966 wxString *arg3 = 0 ;
7967 wxString *arg4 = 0 ;
7968 wxDateTime arg5 ;
7969 wxFSFile *result;
7970 wxPyInputStream *temp1 ;
7971 bool temp2 = false ;
7972 bool temp3 = false ;
7973 bool temp4 = false ;
7974 PyObject * obj0 = 0 ;
7975 PyObject * obj1 = 0 ;
7976 PyObject * obj2 = 0 ;
7977 PyObject * obj3 = 0 ;
7978 PyObject * obj4 = 0 ;
7979 char *kwnames[] = {
7980 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7981 };
7982
7983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7984 {
7985 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7986 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7987 } else {
7988 PyErr_Clear(); // clear the failure of the wxPyConvert above
7989 arg1 = wxPyCBInputStream_create(obj0, true);
7990 if (arg1 == NULL) {
7991 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7992 SWIG_fail;
7993 }
7994 }
7995 }
7996 {
7997 arg2 = wxString_in_helper(obj1);
7998 if (arg2 == NULL) SWIG_fail;
7999 temp2 = true;
8000 }
8001 {
8002 arg3 = wxString_in_helper(obj2);
8003 if (arg3 == NULL) SWIG_fail;
8004 temp3 = true;
8005 }
8006 {
8007 arg4 = wxString_in_helper(obj3);
8008 if (arg4 == NULL) SWIG_fail;
8009 temp4 = true;
8010 }
8011 {
8012 wxDateTime * argp;
8013 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8014 if (SWIG_arg_fail(5)) SWIG_fail;
8015 if (argp == NULL) {
8016 SWIG_null_ref("wxDateTime");
8017 }
8018 if (SWIG_arg_fail(5)) SWIG_fail;
8019 arg5 = *argp;
8020 }
8021 {
8022 PyThreadState* __tstate = wxPyBeginAllowThreads();
8023 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8024
8025 wxPyEndAllowThreads(__tstate);
8026 if (PyErr_Occurred()) SWIG_fail;
8027 }
8028 {
8029 resultobj = wxPyMake_wxObject(result, 1);
8030 }
8031 {
8032 if (temp2)
8033 delete arg2;
8034 }
8035 {
8036 if (temp3)
8037 delete arg3;
8038 }
8039 {
8040 if (temp4)
8041 delete arg4;
8042 }
8043 return resultobj;
8044 fail:
8045 {
8046 if (temp2)
8047 delete arg2;
8048 }
8049 {
8050 if (temp3)
8051 delete arg3;
8052 }
8053 {
8054 if (temp4)
8055 delete arg4;
8056 }
8057 return NULL;
8058 }
8059
8060
8061 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8062 PyObject *resultobj;
8063 wxFSFile *arg1 = (wxFSFile *) 0 ;
8064 PyObject * obj0 = 0 ;
8065 char *kwnames[] = {
8066 (char *) "self", NULL
8067 };
8068
8069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8071 if (SWIG_arg_fail(1)) SWIG_fail;
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 delete arg1;
8075
8076 wxPyEndAllowThreads(__tstate);
8077 if (PyErr_Occurred()) SWIG_fail;
8078 }
8079 Py_INCREF(Py_None); resultobj = Py_None;
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8087 PyObject *resultobj;
8088 wxFSFile *arg1 = (wxFSFile *) 0 ;
8089 wxInputStream *result;
8090 PyObject * obj0 = 0 ;
8091 char *kwnames[] = {
8092 (char *) "self", NULL
8093 };
8094
8095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8097 if (SWIG_arg_fail(1)) SWIG_fail;
8098 {
8099 PyThreadState* __tstate = wxPyBeginAllowThreads();
8100 result = (wxInputStream *)(arg1)->GetStream();
8101
8102 wxPyEndAllowThreads(__tstate);
8103 if (PyErr_Occurred()) SWIG_fail;
8104 }
8105 {
8106 wxPyInputStream * _ptr = NULL;
8107
8108 if (result) {
8109 _ptr = new wxPyInputStream(result);
8110 }
8111 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8112 }
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8120 PyObject *resultobj;
8121 wxFSFile *arg1 = (wxFSFile *) 0 ;
8122 wxString *result;
8123 PyObject * obj0 = 0 ;
8124 char *kwnames[] = {
8125 (char *) "self", NULL
8126 };
8127
8128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8130 if (SWIG_arg_fail(1)) SWIG_fail;
8131 {
8132 PyThreadState* __tstate = wxPyBeginAllowThreads();
8133 {
8134 wxString const &_result_ref = (arg1)->GetMimeType();
8135 result = (wxString *) &_result_ref;
8136 }
8137
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 {
8142 #if wxUSE_UNICODE
8143 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8144 #else
8145 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8146 #endif
8147 }
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8155 PyObject *resultobj;
8156 wxFSFile *arg1 = (wxFSFile *) 0 ;
8157 wxString *result;
8158 PyObject * obj0 = 0 ;
8159 char *kwnames[] = {
8160 (char *) "self", NULL
8161 };
8162
8163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8165 if (SWIG_arg_fail(1)) SWIG_fail;
8166 {
8167 PyThreadState* __tstate = wxPyBeginAllowThreads();
8168 {
8169 wxString const &_result_ref = (arg1)->GetLocation();
8170 result = (wxString *) &_result_ref;
8171 }
8172
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 {
8177 #if wxUSE_UNICODE
8178 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8179 #else
8180 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8181 #endif
8182 }
8183 return resultobj;
8184 fail:
8185 return NULL;
8186 }
8187
8188
8189 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8190 PyObject *resultobj;
8191 wxFSFile *arg1 = (wxFSFile *) 0 ;
8192 wxString *result;
8193 PyObject * obj0 = 0 ;
8194 char *kwnames[] = {
8195 (char *) "self", NULL
8196 };
8197
8198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8200 if (SWIG_arg_fail(1)) SWIG_fail;
8201 {
8202 PyThreadState* __tstate = wxPyBeginAllowThreads();
8203 {
8204 wxString const &_result_ref = (arg1)->GetAnchor();
8205 result = (wxString *) &_result_ref;
8206 }
8207
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 {
8212 #if wxUSE_UNICODE
8213 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8214 #else
8215 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8216 #endif
8217 }
8218 return resultobj;
8219 fail:
8220 return NULL;
8221 }
8222
8223
8224 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8225 PyObject *resultobj;
8226 wxFSFile *arg1 = (wxFSFile *) 0 ;
8227 wxDateTime result;
8228 PyObject * obj0 = 0 ;
8229 char *kwnames[] = {
8230 (char *) "self", NULL
8231 };
8232
8233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8235 if (SWIG_arg_fail(1)) SWIG_fail;
8236 {
8237 PyThreadState* __tstate = wxPyBeginAllowThreads();
8238 result = (arg1)->GetModificationTime();
8239
8240 wxPyEndAllowThreads(__tstate);
8241 if (PyErr_Occurred()) SWIG_fail;
8242 }
8243 {
8244 wxDateTime * resultptr;
8245 resultptr = new wxDateTime((wxDateTime &)(result));
8246 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8247 }
8248 return resultobj;
8249 fail:
8250 return NULL;
8251 }
8252
8253
8254 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8255 PyObject *obj;
8256 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8257 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8258 Py_INCREF(obj);
8259 return Py_BuildValue((char *)"");
8260 }
8261 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8262 PyObject *obj;
8263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8264 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8265 Py_INCREF(obj);
8266 return Py_BuildValue((char *)"");
8267 }
8268 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8269 PyObject *resultobj;
8270 wxPyFileSystemHandler *result;
8271 char *kwnames[] = {
8272 NULL
8273 };
8274
8275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8276 {
8277 PyThreadState* __tstate = wxPyBeginAllowThreads();
8278 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8279
8280 wxPyEndAllowThreads(__tstate);
8281 if (PyErr_Occurred()) SWIG_fail;
8282 }
8283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8284 return resultobj;
8285 fail:
8286 return NULL;
8287 }
8288
8289
8290 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8291 PyObject *resultobj;
8292 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8293 PyObject *arg2 = (PyObject *) 0 ;
8294 PyObject *arg3 = (PyObject *) 0 ;
8295 PyObject * obj0 = 0 ;
8296 PyObject * obj1 = 0 ;
8297 PyObject * obj2 = 0 ;
8298 char *kwnames[] = {
8299 (char *) "self",(char *) "self",(char *) "_class", NULL
8300 };
8301
8302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8304 if (SWIG_arg_fail(1)) SWIG_fail;
8305 arg2 = obj1;
8306 arg3 = obj2;
8307 {
8308 PyThreadState* __tstate = wxPyBeginAllowThreads();
8309 (arg1)->_setCallbackInfo(arg2,arg3);
8310
8311 wxPyEndAllowThreads(__tstate);
8312 if (PyErr_Occurred()) SWIG_fail;
8313 }
8314 Py_INCREF(Py_None); resultobj = Py_None;
8315 return resultobj;
8316 fail:
8317 return NULL;
8318 }
8319
8320
8321 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8322 PyObject *resultobj;
8323 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8324 wxString *arg2 = 0 ;
8325 bool result;
8326 bool temp2 = false ;
8327 PyObject * obj0 = 0 ;
8328 PyObject * obj1 = 0 ;
8329 char *kwnames[] = {
8330 (char *) "self",(char *) "location", NULL
8331 };
8332
8333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8335 if (SWIG_arg_fail(1)) SWIG_fail;
8336 {
8337 arg2 = wxString_in_helper(obj1);
8338 if (arg2 == NULL) SWIG_fail;
8339 temp2 = true;
8340 }
8341 {
8342 PyThreadState* __tstate = wxPyBeginAllowThreads();
8343 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8344
8345 wxPyEndAllowThreads(__tstate);
8346 if (PyErr_Occurred()) SWIG_fail;
8347 }
8348 {
8349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8350 }
8351 {
8352 if (temp2)
8353 delete arg2;
8354 }
8355 return resultobj;
8356 fail:
8357 {
8358 if (temp2)
8359 delete arg2;
8360 }
8361 return NULL;
8362 }
8363
8364
8365 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8366 PyObject *resultobj;
8367 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8368 wxFileSystem *arg2 = 0 ;
8369 wxString *arg3 = 0 ;
8370 wxFSFile *result;
8371 bool temp3 = false ;
8372 PyObject * obj0 = 0 ;
8373 PyObject * obj1 = 0 ;
8374 PyObject * obj2 = 0 ;
8375 char *kwnames[] = {
8376 (char *) "self",(char *) "fs",(char *) "location", NULL
8377 };
8378
8379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8381 if (SWIG_arg_fail(1)) SWIG_fail;
8382 {
8383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8384 if (SWIG_arg_fail(2)) SWIG_fail;
8385 if (arg2 == NULL) {
8386 SWIG_null_ref("wxFileSystem");
8387 }
8388 if (SWIG_arg_fail(2)) SWIG_fail;
8389 }
8390 {
8391 arg3 = wxString_in_helper(obj2);
8392 if (arg3 == NULL) SWIG_fail;
8393 temp3 = true;
8394 }
8395 {
8396 PyThreadState* __tstate = wxPyBeginAllowThreads();
8397 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8398
8399 wxPyEndAllowThreads(__tstate);
8400 if (PyErr_Occurred()) SWIG_fail;
8401 }
8402 {
8403 resultobj = wxPyMake_wxObject(result, 1);
8404 }
8405 {
8406 if (temp3)
8407 delete arg3;
8408 }
8409 return resultobj;
8410 fail:
8411 {
8412 if (temp3)
8413 delete arg3;
8414 }
8415 return NULL;
8416 }
8417
8418
8419 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8420 PyObject *resultobj;
8421 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8422 wxString *arg2 = 0 ;
8423 int arg3 = (int) 0 ;
8424 wxString result;
8425 bool temp2 = false ;
8426 PyObject * obj0 = 0 ;
8427 PyObject * obj1 = 0 ;
8428 PyObject * obj2 = 0 ;
8429 char *kwnames[] = {
8430 (char *) "self",(char *) "spec",(char *) "flags", NULL
8431 };
8432
8433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8435 if (SWIG_arg_fail(1)) SWIG_fail;
8436 {
8437 arg2 = wxString_in_helper(obj1);
8438 if (arg2 == NULL) SWIG_fail;
8439 temp2 = true;
8440 }
8441 if (obj2) {
8442 {
8443 arg3 = (int)(SWIG_As_int(obj2));
8444 if (SWIG_arg_fail(3)) SWIG_fail;
8445 }
8446 }
8447 {
8448 PyThreadState* __tstate = wxPyBeginAllowThreads();
8449 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8450
8451 wxPyEndAllowThreads(__tstate);
8452 if (PyErr_Occurred()) SWIG_fail;
8453 }
8454 {
8455 #if wxUSE_UNICODE
8456 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8457 #else
8458 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8459 #endif
8460 }
8461 {
8462 if (temp2)
8463 delete arg2;
8464 }
8465 return resultobj;
8466 fail:
8467 {
8468 if (temp2)
8469 delete arg2;
8470 }
8471 return NULL;
8472 }
8473
8474
8475 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8476 PyObject *resultobj;
8477 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8478 wxString result;
8479 PyObject * obj0 = 0 ;
8480 char *kwnames[] = {
8481 (char *) "self", NULL
8482 };
8483
8484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8486 if (SWIG_arg_fail(1)) SWIG_fail;
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 result = (arg1)->FindNext();
8490
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 {
8495 #if wxUSE_UNICODE
8496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8497 #else
8498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8499 #endif
8500 }
8501 return resultobj;
8502 fail:
8503 return NULL;
8504 }
8505
8506
8507 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8508 PyObject *resultobj;
8509 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8510 wxString *arg2 = 0 ;
8511 wxString result;
8512 bool temp2 = false ;
8513 PyObject * obj0 = 0 ;
8514 PyObject * obj1 = 0 ;
8515 char *kwnames[] = {
8516 (char *) "self",(char *) "location", NULL
8517 };
8518
8519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8521 if (SWIG_arg_fail(1)) SWIG_fail;
8522 {
8523 arg2 = wxString_in_helper(obj1);
8524 if (arg2 == NULL) SWIG_fail;
8525 temp2 = true;
8526 }
8527 {
8528 PyThreadState* __tstate = wxPyBeginAllowThreads();
8529 result = (arg1)->GetProtocol((wxString const &)*arg2);
8530
8531 wxPyEndAllowThreads(__tstate);
8532 if (PyErr_Occurred()) SWIG_fail;
8533 }
8534 {
8535 #if wxUSE_UNICODE
8536 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8537 #else
8538 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8539 #endif
8540 }
8541 {
8542 if (temp2)
8543 delete arg2;
8544 }
8545 return resultobj;
8546 fail:
8547 {
8548 if (temp2)
8549 delete arg2;
8550 }
8551 return NULL;
8552 }
8553
8554
8555 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj;
8557 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8558 wxString *arg2 = 0 ;
8559 wxString result;
8560 bool temp2 = false ;
8561 PyObject * obj0 = 0 ;
8562 PyObject * obj1 = 0 ;
8563 char *kwnames[] = {
8564 (char *) "self",(char *) "location", NULL
8565 };
8566
8567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8569 if (SWIG_arg_fail(1)) SWIG_fail;
8570 {
8571 arg2 = wxString_in_helper(obj1);
8572 if (arg2 == NULL) SWIG_fail;
8573 temp2 = true;
8574 }
8575 {
8576 PyThreadState* __tstate = wxPyBeginAllowThreads();
8577 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8578
8579 wxPyEndAllowThreads(__tstate);
8580 if (PyErr_Occurred()) SWIG_fail;
8581 }
8582 {
8583 #if wxUSE_UNICODE
8584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8585 #else
8586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8587 #endif
8588 }
8589 {
8590 if (temp2)
8591 delete arg2;
8592 }
8593 return resultobj;
8594 fail:
8595 {
8596 if (temp2)
8597 delete arg2;
8598 }
8599 return NULL;
8600 }
8601
8602
8603 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8604 PyObject *resultobj;
8605 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8606 wxString *arg2 = 0 ;
8607 wxString result;
8608 bool temp2 = false ;
8609 PyObject * obj0 = 0 ;
8610 PyObject * obj1 = 0 ;
8611 char *kwnames[] = {
8612 (char *) "self",(char *) "location", NULL
8613 };
8614
8615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8617 if (SWIG_arg_fail(1)) SWIG_fail;
8618 {
8619 arg2 = wxString_in_helper(obj1);
8620 if (arg2 == NULL) SWIG_fail;
8621 temp2 = true;
8622 }
8623 {
8624 PyThreadState* __tstate = wxPyBeginAllowThreads();
8625 result = (arg1)->GetAnchor((wxString const &)*arg2);
8626
8627 wxPyEndAllowThreads(__tstate);
8628 if (PyErr_Occurred()) SWIG_fail;
8629 }
8630 {
8631 #if wxUSE_UNICODE
8632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8633 #else
8634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8635 #endif
8636 }
8637 {
8638 if (temp2)
8639 delete arg2;
8640 }
8641 return resultobj;
8642 fail:
8643 {
8644 if (temp2)
8645 delete arg2;
8646 }
8647 return NULL;
8648 }
8649
8650
8651 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8652 PyObject *resultobj;
8653 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8654 wxString *arg2 = 0 ;
8655 wxString result;
8656 bool temp2 = false ;
8657 PyObject * obj0 = 0 ;
8658 PyObject * obj1 = 0 ;
8659 char *kwnames[] = {
8660 (char *) "self",(char *) "location", NULL
8661 };
8662
8663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8665 if (SWIG_arg_fail(1)) SWIG_fail;
8666 {
8667 arg2 = wxString_in_helper(obj1);
8668 if (arg2 == NULL) SWIG_fail;
8669 temp2 = true;
8670 }
8671 {
8672 PyThreadState* __tstate = wxPyBeginAllowThreads();
8673 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8674
8675 wxPyEndAllowThreads(__tstate);
8676 if (PyErr_Occurred()) SWIG_fail;
8677 }
8678 {
8679 #if wxUSE_UNICODE
8680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8681 #else
8682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8683 #endif
8684 }
8685 {
8686 if (temp2)
8687 delete arg2;
8688 }
8689 return resultobj;
8690 fail:
8691 {
8692 if (temp2)
8693 delete arg2;
8694 }
8695 return NULL;
8696 }
8697
8698
8699 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8700 PyObject *resultobj;
8701 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8702 wxString *arg2 = 0 ;
8703 wxString result;
8704 bool temp2 = false ;
8705 PyObject * obj0 = 0 ;
8706 PyObject * obj1 = 0 ;
8707 char *kwnames[] = {
8708 (char *) "self",(char *) "location", NULL
8709 };
8710
8711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8713 if (SWIG_arg_fail(1)) SWIG_fail;
8714 {
8715 arg2 = wxString_in_helper(obj1);
8716 if (arg2 == NULL) SWIG_fail;
8717 temp2 = true;
8718 }
8719 {
8720 PyThreadState* __tstate = wxPyBeginAllowThreads();
8721 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8722
8723 wxPyEndAllowThreads(__tstate);
8724 if (PyErr_Occurred()) SWIG_fail;
8725 }
8726 {
8727 #if wxUSE_UNICODE
8728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8729 #else
8730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8731 #endif
8732 }
8733 {
8734 if (temp2)
8735 delete arg2;
8736 }
8737 return resultobj;
8738 fail:
8739 {
8740 if (temp2)
8741 delete arg2;
8742 }
8743 return NULL;
8744 }
8745
8746
8747 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8748 PyObject *obj;
8749 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8750 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8751 Py_INCREF(obj);
8752 return Py_BuildValue((char *)"");
8753 }
8754 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8755 PyObject *resultobj;
8756 wxFileSystem *result;
8757 char *kwnames[] = {
8758 NULL
8759 };
8760
8761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8762 {
8763 PyThreadState* __tstate = wxPyBeginAllowThreads();
8764 result = (wxFileSystem *)new wxFileSystem();
8765
8766 wxPyEndAllowThreads(__tstate);
8767 if (PyErr_Occurred()) SWIG_fail;
8768 }
8769 {
8770 resultobj = wxPyMake_wxObject(result, 1);
8771 }
8772 return resultobj;
8773 fail:
8774 return NULL;
8775 }
8776
8777
8778 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8779 PyObject *resultobj;
8780 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8781 PyObject * obj0 = 0 ;
8782 char *kwnames[] = {
8783 (char *) "self", NULL
8784 };
8785
8786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8788 if (SWIG_arg_fail(1)) SWIG_fail;
8789 {
8790 PyThreadState* __tstate = wxPyBeginAllowThreads();
8791 delete arg1;
8792
8793 wxPyEndAllowThreads(__tstate);
8794 if (PyErr_Occurred()) SWIG_fail;
8795 }
8796 Py_INCREF(Py_None); resultobj = Py_None;
8797 return resultobj;
8798 fail:
8799 return NULL;
8800 }
8801
8802
8803 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8804 PyObject *resultobj;
8805 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8806 wxString *arg2 = 0 ;
8807 bool arg3 = (bool) false ;
8808 bool temp2 = false ;
8809 PyObject * obj0 = 0 ;
8810 PyObject * obj1 = 0 ;
8811 PyObject * obj2 = 0 ;
8812 char *kwnames[] = {
8813 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8814 };
8815
8816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8818 if (SWIG_arg_fail(1)) SWIG_fail;
8819 {
8820 arg2 = wxString_in_helper(obj1);
8821 if (arg2 == NULL) SWIG_fail;
8822 temp2 = true;
8823 }
8824 if (obj2) {
8825 {
8826 arg3 = (bool)(SWIG_As_bool(obj2));
8827 if (SWIG_arg_fail(3)) SWIG_fail;
8828 }
8829 }
8830 {
8831 PyThreadState* __tstate = wxPyBeginAllowThreads();
8832 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8833
8834 wxPyEndAllowThreads(__tstate);
8835 if (PyErr_Occurred()) SWIG_fail;
8836 }
8837 Py_INCREF(Py_None); resultobj = Py_None;
8838 {
8839 if (temp2)
8840 delete arg2;
8841 }
8842 return resultobj;
8843 fail:
8844 {
8845 if (temp2)
8846 delete arg2;
8847 }
8848 return NULL;
8849 }
8850
8851
8852 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8853 PyObject *resultobj;
8854 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8855 wxString result;
8856 PyObject * obj0 = 0 ;
8857 char *kwnames[] = {
8858 (char *) "self", NULL
8859 };
8860
8861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8863 if (SWIG_arg_fail(1)) SWIG_fail;
8864 {
8865 PyThreadState* __tstate = wxPyBeginAllowThreads();
8866 result = (arg1)->GetPath();
8867
8868 wxPyEndAllowThreads(__tstate);
8869 if (PyErr_Occurred()) SWIG_fail;
8870 }
8871 {
8872 #if wxUSE_UNICODE
8873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8874 #else
8875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8876 #endif
8877 }
8878 return resultobj;
8879 fail:
8880 return NULL;
8881 }
8882
8883
8884 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj;
8886 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8887 wxString *arg2 = 0 ;
8888 wxFSFile *result;
8889 bool temp2 = false ;
8890 PyObject * obj0 = 0 ;
8891 PyObject * obj1 = 0 ;
8892 char *kwnames[] = {
8893 (char *) "self",(char *) "location", NULL
8894 };
8895
8896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8898 if (SWIG_arg_fail(1)) SWIG_fail;
8899 {
8900 arg2 = wxString_in_helper(obj1);
8901 if (arg2 == NULL) SWIG_fail;
8902 temp2 = true;
8903 }
8904 {
8905 PyThreadState* __tstate = wxPyBeginAllowThreads();
8906 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8907
8908 wxPyEndAllowThreads(__tstate);
8909 if (PyErr_Occurred()) SWIG_fail;
8910 }
8911 {
8912 resultobj = wxPyMake_wxObject(result, 1);
8913 }
8914 {
8915 if (temp2)
8916 delete arg2;
8917 }
8918 return resultobj;
8919 fail:
8920 {
8921 if (temp2)
8922 delete arg2;
8923 }
8924 return NULL;
8925 }
8926
8927
8928 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8929 PyObject *resultobj;
8930 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8931 wxString *arg2 = 0 ;
8932 int arg3 = (int) 0 ;
8933 wxString result;
8934 bool temp2 = false ;
8935 PyObject * obj0 = 0 ;
8936 PyObject * obj1 = 0 ;
8937 PyObject * obj2 = 0 ;
8938 char *kwnames[] = {
8939 (char *) "self",(char *) "spec",(char *) "flags", NULL
8940 };
8941
8942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8944 if (SWIG_arg_fail(1)) SWIG_fail;
8945 {
8946 arg2 = wxString_in_helper(obj1);
8947 if (arg2 == NULL) SWIG_fail;
8948 temp2 = true;
8949 }
8950 if (obj2) {
8951 {
8952 arg3 = (int)(SWIG_As_int(obj2));
8953 if (SWIG_arg_fail(3)) SWIG_fail;
8954 }
8955 }
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8959
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 {
8964 #if wxUSE_UNICODE
8965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8966 #else
8967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8968 #endif
8969 }
8970 {
8971 if (temp2)
8972 delete arg2;
8973 }
8974 return resultobj;
8975 fail:
8976 {
8977 if (temp2)
8978 delete arg2;
8979 }
8980 return NULL;
8981 }
8982
8983
8984 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8985 PyObject *resultobj;
8986 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8987 wxString result;
8988 PyObject * obj0 = 0 ;
8989 char *kwnames[] = {
8990 (char *) "self", NULL
8991 };
8992
8993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8995 if (SWIG_arg_fail(1)) SWIG_fail;
8996 {
8997 PyThreadState* __tstate = wxPyBeginAllowThreads();
8998 result = (arg1)->FindNext();
8999
9000 wxPyEndAllowThreads(__tstate);
9001 if (PyErr_Occurred()) SWIG_fail;
9002 }
9003 {
9004 #if wxUSE_UNICODE
9005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9006 #else
9007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9008 #endif
9009 }
9010 return resultobj;
9011 fail:
9012 return NULL;
9013 }
9014
9015
9016 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9017 PyObject *resultobj;
9018 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9019 PyObject * obj0 = 0 ;
9020 char *kwnames[] = {
9021 (char *) "handler", NULL
9022 };
9023
9024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9026 if (SWIG_arg_fail(1)) SWIG_fail;
9027 {
9028 PyThreadState* __tstate = wxPyBeginAllowThreads();
9029 wxFileSystem::AddHandler(arg1);
9030
9031 wxPyEndAllowThreads(__tstate);
9032 if (PyErr_Occurred()) SWIG_fail;
9033 }
9034 Py_INCREF(Py_None); resultobj = Py_None;
9035 return resultobj;
9036 fail:
9037 return NULL;
9038 }
9039
9040
9041 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj;
9043 char *kwnames[] = {
9044 NULL
9045 };
9046
9047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9048 {
9049 PyThreadState* __tstate = wxPyBeginAllowThreads();
9050 wxFileSystem::CleanUpHandlers();
9051
9052 wxPyEndAllowThreads(__tstate);
9053 if (PyErr_Occurred()) SWIG_fail;
9054 }
9055 Py_INCREF(Py_None); resultobj = Py_None;
9056 return resultobj;
9057 fail:
9058 return NULL;
9059 }
9060
9061
9062 static PyObject *_wrap_FileSystem_FileNameToURL(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 *) "filename", NULL
9070 };
9071
9072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",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 = wxFileSystem::FileNameToURL((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 *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9107 PyObject *resultobj;
9108 wxString *arg1 = 0 ;
9109 wxString result;
9110 bool temp1 = false ;
9111 PyObject * obj0 = 0 ;
9112 char *kwnames[] = {
9113 (char *) "url", NULL
9114 };
9115
9116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9117 {
9118 arg1 = wxString_in_helper(obj0);
9119 if (arg1 == NULL) SWIG_fail;
9120 temp1 = true;
9121 }
9122 {
9123 PyThreadState* __tstate = wxPyBeginAllowThreads();
9124 result = FileSystem_URLToFileName((wxString const &)*arg1);
9125
9126 wxPyEndAllowThreads(__tstate);
9127 if (PyErr_Occurred()) SWIG_fail;
9128 }
9129 {
9130 #if wxUSE_UNICODE
9131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9132 #else
9133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9134 #endif
9135 }
9136 {
9137 if (temp1)
9138 delete arg1;
9139 }
9140 return resultobj;
9141 fail:
9142 {
9143 if (temp1)
9144 delete arg1;
9145 }
9146 return NULL;
9147 }
9148
9149
9150 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9151 PyObject *obj;
9152 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9153 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9154 Py_INCREF(obj);
9155 return Py_BuildValue((char *)"");
9156 }
9157 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9158 PyObject *resultobj;
9159 wxInternetFSHandler *result;
9160 char *kwnames[] = {
9161 NULL
9162 };
9163
9164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9165 {
9166 PyThreadState* __tstate = wxPyBeginAllowThreads();
9167 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9168
9169 wxPyEndAllowThreads(__tstate);
9170 if (PyErr_Occurred()) SWIG_fail;
9171 }
9172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9173 return resultobj;
9174 fail:
9175 return NULL;
9176 }
9177
9178
9179 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9180 PyObject *resultobj;
9181 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9182 wxString *arg2 = 0 ;
9183 bool result;
9184 bool temp2 = false ;
9185 PyObject * obj0 = 0 ;
9186 PyObject * obj1 = 0 ;
9187 char *kwnames[] = {
9188 (char *) "self",(char *) "location", NULL
9189 };
9190
9191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9193 if (SWIG_arg_fail(1)) SWIG_fail;
9194 {
9195 arg2 = wxString_in_helper(obj1);
9196 if (arg2 == NULL) SWIG_fail;
9197 temp2 = true;
9198 }
9199 {
9200 PyThreadState* __tstate = wxPyBeginAllowThreads();
9201 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9202
9203 wxPyEndAllowThreads(__tstate);
9204 if (PyErr_Occurred()) SWIG_fail;
9205 }
9206 {
9207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9208 }
9209 {
9210 if (temp2)
9211 delete arg2;
9212 }
9213 return resultobj;
9214 fail:
9215 {
9216 if (temp2)
9217 delete arg2;
9218 }
9219 return NULL;
9220 }
9221
9222
9223 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9224 PyObject *resultobj;
9225 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9226 wxFileSystem *arg2 = 0 ;
9227 wxString *arg3 = 0 ;
9228 wxFSFile *result;
9229 bool temp3 = false ;
9230 PyObject * obj0 = 0 ;
9231 PyObject * obj1 = 0 ;
9232 PyObject * obj2 = 0 ;
9233 char *kwnames[] = {
9234 (char *) "self",(char *) "fs",(char *) "location", NULL
9235 };
9236
9237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9239 if (SWIG_arg_fail(1)) SWIG_fail;
9240 {
9241 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9242 if (SWIG_arg_fail(2)) SWIG_fail;
9243 if (arg2 == NULL) {
9244 SWIG_null_ref("wxFileSystem");
9245 }
9246 if (SWIG_arg_fail(2)) SWIG_fail;
9247 }
9248 {
9249 arg3 = wxString_in_helper(obj2);
9250 if (arg3 == NULL) SWIG_fail;
9251 temp3 = true;
9252 }
9253 {
9254 PyThreadState* __tstate = wxPyBeginAllowThreads();
9255 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9256
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 {
9261 resultobj = wxPyMake_wxObject(result, 1);
9262 }
9263 {
9264 if (temp3)
9265 delete arg3;
9266 }
9267 return resultobj;
9268 fail:
9269 {
9270 if (temp3)
9271 delete arg3;
9272 }
9273 return NULL;
9274 }
9275
9276
9277 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9278 PyObject *obj;
9279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9280 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9281 Py_INCREF(obj);
9282 return Py_BuildValue((char *)"");
9283 }
9284 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9285 PyObject *resultobj;
9286 wxZipFSHandler *result;
9287 char *kwnames[] = {
9288 NULL
9289 };
9290
9291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9292 {
9293 PyThreadState* __tstate = wxPyBeginAllowThreads();
9294 result = (wxZipFSHandler *)new wxZipFSHandler();
9295
9296 wxPyEndAllowThreads(__tstate);
9297 if (PyErr_Occurred()) SWIG_fail;
9298 }
9299 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9300 return resultobj;
9301 fail:
9302 return NULL;
9303 }
9304
9305
9306 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9307 PyObject *resultobj;
9308 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9309 wxString *arg2 = 0 ;
9310 bool result;
9311 bool temp2 = false ;
9312 PyObject * obj0 = 0 ;
9313 PyObject * obj1 = 0 ;
9314 char *kwnames[] = {
9315 (char *) "self",(char *) "location", NULL
9316 };
9317
9318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9320 if (SWIG_arg_fail(1)) SWIG_fail;
9321 {
9322 arg2 = wxString_in_helper(obj1);
9323 if (arg2 == NULL) SWIG_fail;
9324 temp2 = true;
9325 }
9326 {
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9329
9330 wxPyEndAllowThreads(__tstate);
9331 if (PyErr_Occurred()) SWIG_fail;
9332 }
9333 {
9334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9335 }
9336 {
9337 if (temp2)
9338 delete arg2;
9339 }
9340 return resultobj;
9341 fail:
9342 {
9343 if (temp2)
9344 delete arg2;
9345 }
9346 return NULL;
9347 }
9348
9349
9350 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9351 PyObject *resultobj;
9352 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9353 wxFileSystem *arg2 = 0 ;
9354 wxString *arg3 = 0 ;
9355 wxFSFile *result;
9356 bool temp3 = false ;
9357 PyObject * obj0 = 0 ;
9358 PyObject * obj1 = 0 ;
9359 PyObject * obj2 = 0 ;
9360 char *kwnames[] = {
9361 (char *) "self",(char *) "fs",(char *) "location", NULL
9362 };
9363
9364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9366 if (SWIG_arg_fail(1)) SWIG_fail;
9367 {
9368 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9369 if (SWIG_arg_fail(2)) SWIG_fail;
9370 if (arg2 == NULL) {
9371 SWIG_null_ref("wxFileSystem");
9372 }
9373 if (SWIG_arg_fail(2)) SWIG_fail;
9374 }
9375 {
9376 arg3 = wxString_in_helper(obj2);
9377 if (arg3 == NULL) SWIG_fail;
9378 temp3 = true;
9379 }
9380 {
9381 PyThreadState* __tstate = wxPyBeginAllowThreads();
9382 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9383
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 {
9388 resultobj = wxPyMake_wxObject(result, 1);
9389 }
9390 {
9391 if (temp3)
9392 delete arg3;
9393 }
9394 return resultobj;
9395 fail:
9396 {
9397 if (temp3)
9398 delete arg3;
9399 }
9400 return NULL;
9401 }
9402
9403
9404 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9405 PyObject *resultobj;
9406 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9407 wxString *arg2 = 0 ;
9408 int arg3 = (int) 0 ;
9409 wxString result;
9410 bool temp2 = false ;
9411 PyObject * obj0 = 0 ;
9412 PyObject * obj1 = 0 ;
9413 PyObject * obj2 = 0 ;
9414 char *kwnames[] = {
9415 (char *) "self",(char *) "spec",(char *) "flags", NULL
9416 };
9417
9418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9420 if (SWIG_arg_fail(1)) SWIG_fail;
9421 {
9422 arg2 = wxString_in_helper(obj1);
9423 if (arg2 == NULL) SWIG_fail;
9424 temp2 = true;
9425 }
9426 if (obj2) {
9427 {
9428 arg3 = (int)(SWIG_As_int(obj2));
9429 if (SWIG_arg_fail(3)) SWIG_fail;
9430 }
9431 }
9432 {
9433 PyThreadState* __tstate = wxPyBeginAllowThreads();
9434 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9435
9436 wxPyEndAllowThreads(__tstate);
9437 if (PyErr_Occurred()) SWIG_fail;
9438 }
9439 {
9440 #if wxUSE_UNICODE
9441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9442 #else
9443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9444 #endif
9445 }
9446 {
9447 if (temp2)
9448 delete arg2;
9449 }
9450 return resultobj;
9451 fail:
9452 {
9453 if (temp2)
9454 delete arg2;
9455 }
9456 return NULL;
9457 }
9458
9459
9460 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9461 PyObject *resultobj;
9462 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9463 wxString result;
9464 PyObject * obj0 = 0 ;
9465 char *kwnames[] = {
9466 (char *) "self", NULL
9467 };
9468
9469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9471 if (SWIG_arg_fail(1)) SWIG_fail;
9472 {
9473 PyThreadState* __tstate = wxPyBeginAllowThreads();
9474 result = (arg1)->FindNext();
9475
9476 wxPyEndAllowThreads(__tstate);
9477 if (PyErr_Occurred()) SWIG_fail;
9478 }
9479 {
9480 #if wxUSE_UNICODE
9481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9482 #else
9483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9484 #endif
9485 }
9486 return resultobj;
9487 fail:
9488 return NULL;
9489 }
9490
9491
9492 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9493 PyObject *obj;
9494 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9495 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9496 Py_INCREF(obj);
9497 return Py_BuildValue((char *)"");
9498 }
9499 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9500 PyObject *resultobj;
9501 wxString *arg1 = 0 ;
9502 wxImage *arg2 = 0 ;
9503 long arg3 ;
9504 bool temp1 = false ;
9505 PyObject * obj0 = 0 ;
9506 PyObject * obj1 = 0 ;
9507 PyObject * obj2 = 0 ;
9508 char *kwnames[] = {
9509 (char *) "filename",(char *) "image",(char *) "type", NULL
9510 };
9511
9512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9513 {
9514 arg1 = wxString_in_helper(obj0);
9515 if (arg1 == NULL) SWIG_fail;
9516 temp1 = true;
9517 }
9518 {
9519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9520 if (SWIG_arg_fail(2)) SWIG_fail;
9521 if (arg2 == NULL) {
9522 SWIG_null_ref("wxImage");
9523 }
9524 if (SWIG_arg_fail(2)) SWIG_fail;
9525 }
9526 {
9527 arg3 = (long)(SWIG_As_long(obj2));
9528 if (SWIG_arg_fail(3)) SWIG_fail;
9529 }
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9533
9534 wxPyEndAllowThreads(__tstate);
9535 if (PyErr_Occurred()) SWIG_fail;
9536 }
9537 Py_INCREF(Py_None); resultobj = Py_None;
9538 {
9539 if (temp1)
9540 delete arg1;
9541 }
9542 return resultobj;
9543 fail:
9544 {
9545 if (temp1)
9546 delete arg1;
9547 }
9548 return NULL;
9549 }
9550
9551
9552 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9553 PyObject *resultobj;
9554 wxString *arg1 = 0 ;
9555 wxBitmap *arg2 = 0 ;
9556 long arg3 ;
9557 bool temp1 = false ;
9558 PyObject * obj0 = 0 ;
9559 PyObject * obj1 = 0 ;
9560 PyObject * obj2 = 0 ;
9561 char *kwnames[] = {
9562 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9563 };
9564
9565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9566 {
9567 arg1 = wxString_in_helper(obj0);
9568 if (arg1 == NULL) SWIG_fail;
9569 temp1 = true;
9570 }
9571 {
9572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9573 if (SWIG_arg_fail(2)) SWIG_fail;
9574 if (arg2 == NULL) {
9575 SWIG_null_ref("wxBitmap");
9576 }
9577 if (SWIG_arg_fail(2)) SWIG_fail;
9578 }
9579 {
9580 arg3 = (long)(SWIG_As_long(obj2));
9581 if (SWIG_arg_fail(3)) SWIG_fail;
9582 }
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9586
9587 wxPyEndAllowThreads(__tstate);
9588 if (PyErr_Occurred()) SWIG_fail;
9589 }
9590 Py_INCREF(Py_None); resultobj = Py_None;
9591 {
9592 if (temp1)
9593 delete arg1;
9594 }
9595 return resultobj;
9596 fail:
9597 {
9598 if (temp1)
9599 delete arg1;
9600 }
9601 return NULL;
9602 }
9603
9604
9605 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9606 PyObject *resultobj;
9607 wxString *arg1 = 0 ;
9608 PyObject *arg2 = (PyObject *) 0 ;
9609 bool temp1 = false ;
9610 PyObject * obj0 = 0 ;
9611 PyObject * obj1 = 0 ;
9612 char *kwnames[] = {
9613 (char *) "filename",(char *) "data", NULL
9614 };
9615
9616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9617 {
9618 arg1 = wxString_in_helper(obj0);
9619 if (arg1 == NULL) SWIG_fail;
9620 temp1 = true;
9621 }
9622 arg2 = obj1;
9623 {
9624 PyThreadState* __tstate = wxPyBeginAllowThreads();
9625 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9626
9627 wxPyEndAllowThreads(__tstate);
9628 if (PyErr_Occurred()) SWIG_fail;
9629 }
9630 Py_INCREF(Py_None); resultobj = Py_None;
9631 {
9632 if (temp1)
9633 delete arg1;
9634 }
9635 return resultobj;
9636 fail:
9637 {
9638 if (temp1)
9639 delete arg1;
9640 }
9641 return NULL;
9642 }
9643
9644
9645 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj;
9647 wxMemoryFSHandler *result;
9648 char *kwnames[] = {
9649 NULL
9650 };
9651
9652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9656
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9668 PyObject *resultobj;
9669 wxString *arg1 = 0 ;
9670 bool temp1 = false ;
9671 PyObject * obj0 = 0 ;
9672 char *kwnames[] = {
9673 (char *) "filename", NULL
9674 };
9675
9676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9677 {
9678 arg1 = wxString_in_helper(obj0);
9679 if (arg1 == NULL) SWIG_fail;
9680 temp1 = true;
9681 }
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9685
9686 wxPyEndAllowThreads(__tstate);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 Py_INCREF(Py_None); resultobj = Py_None;
9690 {
9691 if (temp1)
9692 delete arg1;
9693 }
9694 return resultobj;
9695 fail:
9696 {
9697 if (temp1)
9698 delete arg1;
9699 }
9700 return NULL;
9701 }
9702
9703
9704 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9705 PyObject *resultobj;
9706 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9707 wxString *arg2 = 0 ;
9708 bool result;
9709 bool temp2 = false ;
9710 PyObject * obj0 = 0 ;
9711 PyObject * obj1 = 0 ;
9712 char *kwnames[] = {
9713 (char *) "self",(char *) "location", NULL
9714 };
9715
9716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9718 if (SWIG_arg_fail(1)) SWIG_fail;
9719 {
9720 arg2 = wxString_in_helper(obj1);
9721 if (arg2 == NULL) SWIG_fail;
9722 temp2 = true;
9723 }
9724 {
9725 PyThreadState* __tstate = wxPyBeginAllowThreads();
9726 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9727
9728 wxPyEndAllowThreads(__tstate);
9729 if (PyErr_Occurred()) SWIG_fail;
9730 }
9731 {
9732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9733 }
9734 {
9735 if (temp2)
9736 delete arg2;
9737 }
9738 return resultobj;
9739 fail:
9740 {
9741 if (temp2)
9742 delete arg2;
9743 }
9744 return NULL;
9745 }
9746
9747
9748 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9749 PyObject *resultobj;
9750 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9751 wxFileSystem *arg2 = 0 ;
9752 wxString *arg3 = 0 ;
9753 wxFSFile *result;
9754 bool temp3 = false ;
9755 PyObject * obj0 = 0 ;
9756 PyObject * obj1 = 0 ;
9757 PyObject * obj2 = 0 ;
9758 char *kwnames[] = {
9759 (char *) "self",(char *) "fs",(char *) "location", NULL
9760 };
9761
9762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9764 if (SWIG_arg_fail(1)) SWIG_fail;
9765 {
9766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9767 if (SWIG_arg_fail(2)) SWIG_fail;
9768 if (arg2 == NULL) {
9769 SWIG_null_ref("wxFileSystem");
9770 }
9771 if (SWIG_arg_fail(2)) SWIG_fail;
9772 }
9773 {
9774 arg3 = wxString_in_helper(obj2);
9775 if (arg3 == NULL) SWIG_fail;
9776 temp3 = true;
9777 }
9778 {
9779 PyThreadState* __tstate = wxPyBeginAllowThreads();
9780 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9781
9782 wxPyEndAllowThreads(__tstate);
9783 if (PyErr_Occurred()) SWIG_fail;
9784 }
9785 {
9786 resultobj = wxPyMake_wxObject(result, 1);
9787 }
9788 {
9789 if (temp3)
9790 delete arg3;
9791 }
9792 return resultobj;
9793 fail:
9794 {
9795 if (temp3)
9796 delete arg3;
9797 }
9798 return NULL;
9799 }
9800
9801
9802 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9803 PyObject *resultobj;
9804 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9805 wxString *arg2 = 0 ;
9806 int arg3 = (int) 0 ;
9807 wxString result;
9808 bool temp2 = false ;
9809 PyObject * obj0 = 0 ;
9810 PyObject * obj1 = 0 ;
9811 PyObject * obj2 = 0 ;
9812 char *kwnames[] = {
9813 (char *) "self",(char *) "spec",(char *) "flags", NULL
9814 };
9815
9816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9818 if (SWIG_arg_fail(1)) SWIG_fail;
9819 {
9820 arg2 = wxString_in_helper(obj1);
9821 if (arg2 == NULL) SWIG_fail;
9822 temp2 = true;
9823 }
9824 if (obj2) {
9825 {
9826 arg3 = (int)(SWIG_As_int(obj2));
9827 if (SWIG_arg_fail(3)) SWIG_fail;
9828 }
9829 }
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9833
9834 wxPyEndAllowThreads(__tstate);
9835 if (PyErr_Occurred()) SWIG_fail;
9836 }
9837 {
9838 #if wxUSE_UNICODE
9839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9840 #else
9841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9842 #endif
9843 }
9844 {
9845 if (temp2)
9846 delete arg2;
9847 }
9848 return resultobj;
9849 fail:
9850 {
9851 if (temp2)
9852 delete arg2;
9853 }
9854 return NULL;
9855 }
9856
9857
9858 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9859 PyObject *resultobj;
9860 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9861 wxString result;
9862 PyObject * obj0 = 0 ;
9863 char *kwnames[] = {
9864 (char *) "self", NULL
9865 };
9866
9867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9869 if (SWIG_arg_fail(1)) SWIG_fail;
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 result = (arg1)->FindNext();
9873
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 {
9878 #if wxUSE_UNICODE
9879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9880 #else
9881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9882 #endif
9883 }
9884 return resultobj;
9885 fail:
9886 return NULL;
9887 }
9888
9889
9890 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9891 PyObject *obj;
9892 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9893 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9894 Py_INCREF(obj);
9895 return Py_BuildValue((char *)"");
9896 }
9897 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9898 PyObject *resultobj;
9899 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9900 wxString result;
9901 PyObject * obj0 = 0 ;
9902 char *kwnames[] = {
9903 (char *) "self", NULL
9904 };
9905
9906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9908 if (SWIG_arg_fail(1)) SWIG_fail;
9909 {
9910 PyThreadState* __tstate = wxPyBeginAllowThreads();
9911 result = (arg1)->GetName();
9912
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 {
9917 #if wxUSE_UNICODE
9918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9919 #else
9920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9921 #endif
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9930 PyObject *resultobj;
9931 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9932 wxString result;
9933 PyObject * obj0 = 0 ;
9934 char *kwnames[] = {
9935 (char *) "self", NULL
9936 };
9937
9938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9940 if (SWIG_arg_fail(1)) SWIG_fail;
9941 {
9942 PyThreadState* __tstate = wxPyBeginAllowThreads();
9943 result = (arg1)->GetExtension();
9944
9945 wxPyEndAllowThreads(__tstate);
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 {
9949 #if wxUSE_UNICODE
9950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9951 #else
9952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9953 #endif
9954 }
9955 return resultobj;
9956 fail:
9957 return NULL;
9958 }
9959
9960
9961 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj;
9963 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9964 long result;
9965 PyObject * obj0 = 0 ;
9966 char *kwnames[] = {
9967 (char *) "self", NULL
9968 };
9969
9970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9972 if (SWIG_arg_fail(1)) SWIG_fail;
9973 {
9974 PyThreadState* __tstate = wxPyBeginAllowThreads();
9975 result = (long)(arg1)->GetType();
9976
9977 wxPyEndAllowThreads(__tstate);
9978 if (PyErr_Occurred()) SWIG_fail;
9979 }
9980 {
9981 resultobj = SWIG_From_long((long)(result));
9982 }
9983 return resultobj;
9984 fail:
9985 return NULL;
9986 }
9987
9988
9989 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9990 PyObject *resultobj;
9991 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9992 wxString result;
9993 PyObject * obj0 = 0 ;
9994 char *kwnames[] = {
9995 (char *) "self", NULL
9996 };
9997
9998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10000 if (SWIG_arg_fail(1)) SWIG_fail;
10001 {
10002 PyThreadState* __tstate = wxPyBeginAllowThreads();
10003 result = (arg1)->GetMimeType();
10004
10005 wxPyEndAllowThreads(__tstate);
10006 if (PyErr_Occurred()) SWIG_fail;
10007 }
10008 {
10009 #if wxUSE_UNICODE
10010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10011 #else
10012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10013 #endif
10014 }
10015 return resultobj;
10016 fail:
10017 return NULL;
10018 }
10019
10020
10021 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10022 PyObject *resultobj;
10023 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10024 wxString *arg2 = 0 ;
10025 bool result;
10026 bool temp2 = false ;
10027 PyObject * obj0 = 0 ;
10028 PyObject * obj1 = 0 ;
10029 char *kwnames[] = {
10030 (char *) "self",(char *) "name", NULL
10031 };
10032
10033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10035 if (SWIG_arg_fail(1)) SWIG_fail;
10036 {
10037 arg2 = wxString_in_helper(obj1);
10038 if (arg2 == NULL) SWIG_fail;
10039 temp2 = true;
10040 }
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 {
10049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10050 }
10051 {
10052 if (temp2)
10053 delete arg2;
10054 }
10055 return resultobj;
10056 fail:
10057 {
10058 if (temp2)
10059 delete arg2;
10060 }
10061 return NULL;
10062 }
10063
10064
10065 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10066 PyObject *resultobj;
10067 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10068 wxString *arg2 = 0 ;
10069 bool temp2 = false ;
10070 PyObject * obj0 = 0 ;
10071 PyObject * obj1 = 0 ;
10072 char *kwnames[] = {
10073 (char *) "self",(char *) "name", NULL
10074 };
10075
10076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10078 if (SWIG_arg_fail(1)) SWIG_fail;
10079 {
10080 arg2 = wxString_in_helper(obj1);
10081 if (arg2 == NULL) SWIG_fail;
10082 temp2 = true;
10083 }
10084 {
10085 PyThreadState* __tstate = wxPyBeginAllowThreads();
10086 (arg1)->SetName((wxString const &)*arg2);
10087
10088 wxPyEndAllowThreads(__tstate);
10089 if (PyErr_Occurred()) SWIG_fail;
10090 }
10091 Py_INCREF(Py_None); resultobj = Py_None;
10092 {
10093 if (temp2)
10094 delete arg2;
10095 }
10096 return resultobj;
10097 fail:
10098 {
10099 if (temp2)
10100 delete arg2;
10101 }
10102 return NULL;
10103 }
10104
10105
10106 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10107 PyObject *resultobj;
10108 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10109 wxString *arg2 = 0 ;
10110 bool temp2 = false ;
10111 PyObject * obj0 = 0 ;
10112 PyObject * obj1 = 0 ;
10113 char *kwnames[] = {
10114 (char *) "self",(char *) "extension", NULL
10115 };
10116
10117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10119 if (SWIG_arg_fail(1)) SWIG_fail;
10120 {
10121 arg2 = wxString_in_helper(obj1);
10122 if (arg2 == NULL) SWIG_fail;
10123 temp2 = true;
10124 }
10125 {
10126 PyThreadState* __tstate = wxPyBeginAllowThreads();
10127 (arg1)->SetExtension((wxString const &)*arg2);
10128
10129 wxPyEndAllowThreads(__tstate);
10130 if (PyErr_Occurred()) SWIG_fail;
10131 }
10132 Py_INCREF(Py_None); resultobj = Py_None;
10133 {
10134 if (temp2)
10135 delete arg2;
10136 }
10137 return resultobj;
10138 fail:
10139 {
10140 if (temp2)
10141 delete arg2;
10142 }
10143 return NULL;
10144 }
10145
10146
10147 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10148 PyObject *resultobj;
10149 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10150 long arg2 ;
10151 PyObject * obj0 = 0 ;
10152 PyObject * obj1 = 0 ;
10153 char *kwnames[] = {
10154 (char *) "self",(char *) "type", NULL
10155 };
10156
10157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10159 if (SWIG_arg_fail(1)) SWIG_fail;
10160 {
10161 arg2 = (long)(SWIG_As_long(obj1));
10162 if (SWIG_arg_fail(2)) SWIG_fail;
10163 }
10164 {
10165 PyThreadState* __tstate = wxPyBeginAllowThreads();
10166 (arg1)->SetType(arg2);
10167
10168 wxPyEndAllowThreads(__tstate);
10169 if (PyErr_Occurred()) SWIG_fail;
10170 }
10171 Py_INCREF(Py_None); resultobj = Py_None;
10172 return resultobj;
10173 fail:
10174 return NULL;
10175 }
10176
10177
10178 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj;
10180 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10181 wxString *arg2 = 0 ;
10182 bool temp2 = false ;
10183 PyObject * obj0 = 0 ;
10184 PyObject * obj1 = 0 ;
10185 char *kwnames[] = {
10186 (char *) "self",(char *) "mimetype", NULL
10187 };
10188
10189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10191 if (SWIG_arg_fail(1)) SWIG_fail;
10192 {
10193 arg2 = wxString_in_helper(obj1);
10194 if (arg2 == NULL) SWIG_fail;
10195 temp2 = true;
10196 }
10197 {
10198 PyThreadState* __tstate = wxPyBeginAllowThreads();
10199 (arg1)->SetMimeType((wxString const &)*arg2);
10200
10201 wxPyEndAllowThreads(__tstate);
10202 if (PyErr_Occurred()) SWIG_fail;
10203 }
10204 Py_INCREF(Py_None); resultobj = Py_None;
10205 {
10206 if (temp2)
10207 delete arg2;
10208 }
10209 return resultobj;
10210 fail:
10211 {
10212 if (temp2)
10213 delete arg2;
10214 }
10215 return NULL;
10216 }
10217
10218
10219 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10220 PyObject *obj;
10221 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10222 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10223 Py_INCREF(obj);
10224 return Py_BuildValue((char *)"");
10225 }
10226 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10227 PyObject *resultobj;
10228 wxImageHistogram *result;
10229 char *kwnames[] = {
10230 NULL
10231 };
10232
10233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10234 {
10235 PyThreadState* __tstate = wxPyBeginAllowThreads();
10236 result = (wxImageHistogram *)new wxImageHistogram();
10237
10238 wxPyEndAllowThreads(__tstate);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10242 return resultobj;
10243 fail:
10244 return NULL;
10245 }
10246
10247
10248 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj;
10250 byte arg1 ;
10251 byte arg2 ;
10252 byte arg3 ;
10253 unsigned long result;
10254 PyObject * obj0 = 0 ;
10255 PyObject * obj1 = 0 ;
10256 PyObject * obj2 = 0 ;
10257 char *kwnames[] = {
10258 (char *) "r",(char *) "g",(char *) "b", NULL
10259 };
10260
10261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10262 {
10263 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10264 if (SWIG_arg_fail(1)) SWIG_fail;
10265 }
10266 {
10267 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10268 if (SWIG_arg_fail(2)) SWIG_fail;
10269 }
10270 {
10271 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10272 if (SWIG_arg_fail(3)) SWIG_fail;
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10277
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 {
10282 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10283 }
10284 return resultobj;
10285 fail:
10286 return NULL;
10287 }
10288
10289
10290 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10291 PyObject *resultobj;
10292 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10293 byte *arg2 = (byte *) 0 ;
10294 byte *arg3 = (byte *) 0 ;
10295 byte *arg4 = (byte *) 0 ;
10296 byte arg5 = (byte) 1 ;
10297 byte arg6 = (byte) 0 ;
10298 byte arg7 = (byte) 0 ;
10299 bool result;
10300 byte temp2 ;
10301 int res2 = 0 ;
10302 byte temp3 ;
10303 int res3 = 0 ;
10304 byte temp4 ;
10305 int res4 = 0 ;
10306 PyObject * obj0 = 0 ;
10307 PyObject * obj1 = 0 ;
10308 PyObject * obj2 = 0 ;
10309 PyObject * obj3 = 0 ;
10310 char *kwnames[] = {
10311 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10312 };
10313
10314 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10315 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10316 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10319 if (SWIG_arg_fail(1)) SWIG_fail;
10320 if (obj1) {
10321 {
10322 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10323 if (SWIG_arg_fail(5)) SWIG_fail;
10324 }
10325 }
10326 if (obj2) {
10327 {
10328 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10329 if (SWIG_arg_fail(6)) SWIG_fail;
10330 }
10331 }
10332 if (obj3) {
10333 {
10334 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10335 if (SWIG_arg_fail(7)) SWIG_fail;
10336 }
10337 }
10338 {
10339 PyThreadState* __tstate = wxPyBeginAllowThreads();
10340 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10341
10342 wxPyEndAllowThreads(__tstate);
10343 if (PyErr_Occurred()) SWIG_fail;
10344 }
10345 {
10346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10347 }
10348 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10349 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10350 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10351 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10352 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10353 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10354 return resultobj;
10355 fail:
10356 return NULL;
10357 }
10358
10359
10360 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10361 PyObject *resultobj;
10362 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10363 unsigned long arg2 ;
10364 unsigned long result;
10365 PyObject * obj0 = 0 ;
10366 PyObject * obj1 = 0 ;
10367 char *kwnames[] = {
10368 (char *) "self",(char *) "key", NULL
10369 };
10370
10371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10373 if (SWIG_arg_fail(1)) SWIG_fail;
10374 {
10375 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10376 if (SWIG_arg_fail(2)) SWIG_fail;
10377 }
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10381
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 {
10386 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10387 }
10388 return resultobj;
10389 fail:
10390 return NULL;
10391 }
10392
10393
10394 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10395 PyObject *resultobj;
10396 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10397 byte arg2 ;
10398 byte arg3 ;
10399 byte arg4 ;
10400 unsigned long result;
10401 PyObject * obj0 = 0 ;
10402 PyObject * obj1 = 0 ;
10403 PyObject * obj2 = 0 ;
10404 PyObject * obj3 = 0 ;
10405 char *kwnames[] = {
10406 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10407 };
10408
10409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10411 if (SWIG_arg_fail(1)) SWIG_fail;
10412 {
10413 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10414 if (SWIG_arg_fail(2)) SWIG_fail;
10415 }
10416 {
10417 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10418 if (SWIG_arg_fail(3)) SWIG_fail;
10419 }
10420 {
10421 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10422 if (SWIG_arg_fail(4)) SWIG_fail;
10423 }
10424 {
10425 PyThreadState* __tstate = wxPyBeginAllowThreads();
10426 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10427
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 {
10432 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10433 }
10434 return resultobj;
10435 fail:
10436 return NULL;
10437 }
10438
10439
10440 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10441 PyObject *resultobj;
10442 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10443 wxColour *arg2 = 0 ;
10444 unsigned long result;
10445 wxColour temp2 ;
10446 PyObject * obj0 = 0 ;
10447 PyObject * obj1 = 0 ;
10448 char *kwnames[] = {
10449 (char *) "self",(char *) "colour", NULL
10450 };
10451
10452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10454 if (SWIG_arg_fail(1)) SWIG_fail;
10455 {
10456 arg2 = &temp2;
10457 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10458 }
10459 {
10460 PyThreadState* __tstate = wxPyBeginAllowThreads();
10461 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10462
10463 wxPyEndAllowThreads(__tstate);
10464 if (PyErr_Occurred()) SWIG_fail;
10465 }
10466 {
10467 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10468 }
10469 return resultobj;
10470 fail:
10471 return NULL;
10472 }
10473
10474
10475 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10476 PyObject *obj;
10477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10478 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10479 Py_INCREF(obj);
10480 return Py_BuildValue((char *)"");
10481 }
10482 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10483 PyObject *resultobj;
10484 wxString *arg1 = 0 ;
10485 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10486 int arg3 = (int) -1 ;
10487 wxImage *result;
10488 bool temp1 = false ;
10489 PyObject * obj0 = 0 ;
10490 PyObject * obj1 = 0 ;
10491 PyObject * obj2 = 0 ;
10492 char *kwnames[] = {
10493 (char *) "name",(char *) "type",(char *) "index", NULL
10494 };
10495
10496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10497 {
10498 arg1 = wxString_in_helper(obj0);
10499 if (arg1 == NULL) SWIG_fail;
10500 temp1 = true;
10501 }
10502 if (obj1) {
10503 {
10504 arg2 = (long)(SWIG_As_long(obj1));
10505 if (SWIG_arg_fail(2)) SWIG_fail;
10506 }
10507 }
10508 if (obj2) {
10509 {
10510 arg3 = (int)(SWIG_As_int(obj2));
10511 if (SWIG_arg_fail(3)) SWIG_fail;
10512 }
10513 }
10514 {
10515 PyThreadState* __tstate = wxPyBeginAllowThreads();
10516 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10517
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10522 {
10523 if (temp1)
10524 delete arg1;
10525 }
10526 return resultobj;
10527 fail:
10528 {
10529 if (temp1)
10530 delete arg1;
10531 }
10532 return NULL;
10533 }
10534
10535
10536 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10537 PyObject *resultobj;
10538 wxImage *arg1 = (wxImage *) 0 ;
10539 PyObject * obj0 = 0 ;
10540 char *kwnames[] = {
10541 (char *) "self", NULL
10542 };
10543
10544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10546 if (SWIG_arg_fail(1)) SWIG_fail;
10547 {
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 delete arg1;
10550
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 Py_INCREF(Py_None); resultobj = Py_None;
10555 return resultobj;
10556 fail:
10557 return NULL;
10558 }
10559
10560
10561 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10562 PyObject *resultobj;
10563 wxString *arg1 = 0 ;
10564 wxString *arg2 = 0 ;
10565 int arg3 = (int) -1 ;
10566 wxImage *result;
10567 bool temp1 = false ;
10568 bool temp2 = false ;
10569 PyObject * obj0 = 0 ;
10570 PyObject * obj1 = 0 ;
10571 PyObject * obj2 = 0 ;
10572 char *kwnames[] = {
10573 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10574 };
10575
10576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10577 {
10578 arg1 = wxString_in_helper(obj0);
10579 if (arg1 == NULL) SWIG_fail;
10580 temp1 = true;
10581 }
10582 {
10583 arg2 = wxString_in_helper(obj1);
10584 if (arg2 == NULL) SWIG_fail;
10585 temp2 = true;
10586 }
10587 if (obj2) {
10588 {
10589 arg3 = (int)(SWIG_As_int(obj2));
10590 if (SWIG_arg_fail(3)) SWIG_fail;
10591 }
10592 }
10593 {
10594 PyThreadState* __tstate = wxPyBeginAllowThreads();
10595 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10596
10597 wxPyEndAllowThreads(__tstate);
10598 if (PyErr_Occurred()) SWIG_fail;
10599 }
10600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10601 {
10602 if (temp1)
10603 delete arg1;
10604 }
10605 {
10606 if (temp2)
10607 delete arg2;
10608 }
10609 return resultobj;
10610 fail:
10611 {
10612 if (temp1)
10613 delete arg1;
10614 }
10615 {
10616 if (temp2)
10617 delete arg2;
10618 }
10619 return NULL;
10620 }
10621
10622
10623 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10624 PyObject *resultobj;
10625 wxInputStream *arg1 = 0 ;
10626 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10627 int arg3 = (int) -1 ;
10628 wxImage *result;
10629 wxPyInputStream *temp1 ;
10630 bool created1 ;
10631 PyObject * obj0 = 0 ;
10632 PyObject * obj1 = 0 ;
10633 PyObject * obj2 = 0 ;
10634 char *kwnames[] = {
10635 (char *) "stream",(char *) "type",(char *) "index", NULL
10636 };
10637
10638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10639 {
10640 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10641 arg1 = temp1->m_wxis;
10642 created1 = false;
10643 } else {
10644 PyErr_Clear(); // clear the failure of the wxPyConvert above
10645 arg1 = wxPyCBInputStream_create(obj0, false);
10646 if (arg1 == NULL) {
10647 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10648 SWIG_fail;
10649 }
10650 created1 = true;
10651 }
10652 }
10653 if (obj1) {
10654 {
10655 arg2 = (long)(SWIG_As_long(obj1));
10656 if (SWIG_arg_fail(2)) SWIG_fail;
10657 }
10658 }
10659 if (obj2) {
10660 {
10661 arg3 = (int)(SWIG_As_int(obj2));
10662 if (SWIG_arg_fail(3)) SWIG_fail;
10663 }
10664 }
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10668
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10673 {
10674 if (created1) delete arg1;
10675 }
10676 return resultobj;
10677 fail:
10678 {
10679 if (created1) delete arg1;
10680 }
10681 return NULL;
10682 }
10683
10684
10685 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10686 PyObject *resultobj;
10687 wxInputStream *arg1 = 0 ;
10688 wxString *arg2 = 0 ;
10689 int arg3 = (int) -1 ;
10690 wxImage *result;
10691 wxPyInputStream *temp1 ;
10692 bool created1 ;
10693 bool temp2 = false ;
10694 PyObject * obj0 = 0 ;
10695 PyObject * obj1 = 0 ;
10696 PyObject * obj2 = 0 ;
10697 char *kwnames[] = {
10698 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10699 };
10700
10701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10702 {
10703 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10704 arg1 = temp1->m_wxis;
10705 created1 = false;
10706 } else {
10707 PyErr_Clear(); // clear the failure of the wxPyConvert above
10708 arg1 = wxPyCBInputStream_create(obj0, false);
10709 if (arg1 == NULL) {
10710 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10711 SWIG_fail;
10712 }
10713 created1 = true;
10714 }
10715 }
10716 {
10717 arg2 = wxString_in_helper(obj1);
10718 if (arg2 == NULL) SWIG_fail;
10719 temp2 = true;
10720 }
10721 if (obj2) {
10722 {
10723 arg3 = (int)(SWIG_As_int(obj2));
10724 if (SWIG_arg_fail(3)) SWIG_fail;
10725 }
10726 }
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10730
10731 wxPyEndAllowThreads(__tstate);
10732 if (PyErr_Occurred()) SWIG_fail;
10733 }
10734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10735 {
10736 if (created1) delete arg1;
10737 }
10738 {
10739 if (temp2)
10740 delete arg2;
10741 }
10742 return resultobj;
10743 fail:
10744 {
10745 if (created1) delete arg1;
10746 }
10747 {
10748 if (temp2)
10749 delete arg2;
10750 }
10751 return NULL;
10752 }
10753
10754
10755 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10756 PyObject *resultobj;
10757 int arg1 = (int) 0 ;
10758 int arg2 = (int) 0 ;
10759 bool arg3 = (bool) true ;
10760 wxImage *result;
10761 PyObject * obj0 = 0 ;
10762 PyObject * obj1 = 0 ;
10763 PyObject * obj2 = 0 ;
10764 char *kwnames[] = {
10765 (char *) "width",(char *) "height",(char *) "clear", NULL
10766 };
10767
10768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10769 if (obj0) {
10770 {
10771 arg1 = (int)(SWIG_As_int(obj0));
10772 if (SWIG_arg_fail(1)) SWIG_fail;
10773 }
10774 }
10775 if (obj1) {
10776 {
10777 arg2 = (int)(SWIG_As_int(obj1));
10778 if (SWIG_arg_fail(2)) SWIG_fail;
10779 }
10780 }
10781 if (obj2) {
10782 {
10783 arg3 = (bool)(SWIG_As_bool(obj2));
10784 if (SWIG_arg_fail(3)) SWIG_fail;
10785 }
10786 }
10787 {
10788 PyThreadState* __tstate = wxPyBeginAllowThreads();
10789 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10790
10791 wxPyEndAllowThreads(__tstate);
10792 if (PyErr_Occurred()) SWIG_fail;
10793 }
10794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10795 return resultobj;
10796 fail:
10797 return NULL;
10798 }
10799
10800
10801 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10802 PyObject *resultobj;
10803 wxBitmap *arg1 = 0 ;
10804 wxImage *result;
10805 PyObject * obj0 = 0 ;
10806 char *kwnames[] = {
10807 (char *) "bitmap", NULL
10808 };
10809
10810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10811 {
10812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10813 if (SWIG_arg_fail(1)) SWIG_fail;
10814 if (arg1 == NULL) {
10815 SWIG_null_ref("wxBitmap");
10816 }
10817 if (SWIG_arg_fail(1)) SWIG_fail;
10818 }
10819 {
10820 if (!wxPyCheckForApp()) SWIG_fail;
10821 PyThreadState* __tstate = wxPyBeginAllowThreads();
10822 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10823
10824 wxPyEndAllowThreads(__tstate);
10825 if (PyErr_Occurred()) SWIG_fail;
10826 }
10827 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10828 return resultobj;
10829 fail:
10830 return NULL;
10831 }
10832
10833
10834 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10835 PyObject *resultobj;
10836 int arg1 ;
10837 int arg2 ;
10838 buffer arg3 ;
10839 int arg4 ;
10840 wxImage *result;
10841 PyObject * obj0 = 0 ;
10842 PyObject * obj1 = 0 ;
10843 PyObject * obj2 = 0 ;
10844 char *kwnames[] = {
10845 (char *) "width",(char *) "height",(char *) "data", NULL
10846 };
10847
10848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10849 {
10850 arg1 = (int)(SWIG_As_int(obj0));
10851 if (SWIG_arg_fail(1)) SWIG_fail;
10852 }
10853 {
10854 arg2 = (int)(SWIG_As_int(obj1));
10855 if (SWIG_arg_fail(2)) SWIG_fail;
10856 }
10857 {
10858 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10859 }
10860 {
10861 PyThreadState* __tstate = wxPyBeginAllowThreads();
10862 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10863
10864 wxPyEndAllowThreads(__tstate);
10865 if (PyErr_Occurred()) SWIG_fail;
10866 }
10867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj;
10876 int arg1 ;
10877 int arg2 ;
10878 buffer arg3 ;
10879 int arg4 ;
10880 buffer arg5 ;
10881 int arg6 ;
10882 wxImage *result;
10883 PyObject * obj0 = 0 ;
10884 PyObject * obj1 = 0 ;
10885 PyObject * obj2 = 0 ;
10886 PyObject * obj3 = 0 ;
10887 char *kwnames[] = {
10888 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10889 };
10890
10891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10892 {
10893 arg1 = (int)(SWIG_As_int(obj0));
10894 if (SWIG_arg_fail(1)) SWIG_fail;
10895 }
10896 {
10897 arg2 = (int)(SWIG_As_int(obj1));
10898 if (SWIG_arg_fail(2)) SWIG_fail;
10899 }
10900 {
10901 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10902 }
10903 {
10904 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10905 }
10906 {
10907 PyThreadState* __tstate = wxPyBeginAllowThreads();
10908 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10909
10910 wxPyEndAllowThreads(__tstate);
10911 if (PyErr_Occurred()) SWIG_fail;
10912 }
10913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10914 return resultobj;
10915 fail:
10916 return NULL;
10917 }
10918
10919
10920 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10921 PyObject *resultobj;
10922 wxImage *arg1 = (wxImage *) 0 ;
10923 int arg2 ;
10924 int arg3 ;
10925 bool arg4 = (bool) true ;
10926 PyObject * obj0 = 0 ;
10927 PyObject * obj1 = 0 ;
10928 PyObject * obj2 = 0 ;
10929 PyObject * obj3 = 0 ;
10930 char *kwnames[] = {
10931 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
10932 };
10933
10934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10936 if (SWIG_arg_fail(1)) SWIG_fail;
10937 {
10938 arg2 = (int)(SWIG_As_int(obj1));
10939 if (SWIG_arg_fail(2)) SWIG_fail;
10940 }
10941 {
10942 arg3 = (int)(SWIG_As_int(obj2));
10943 if (SWIG_arg_fail(3)) SWIG_fail;
10944 }
10945 if (obj3) {
10946 {
10947 arg4 = (bool)(SWIG_As_bool(obj3));
10948 if (SWIG_arg_fail(4)) SWIG_fail;
10949 }
10950 }
10951 {
10952 PyThreadState* __tstate = wxPyBeginAllowThreads();
10953 (arg1)->Create(arg2,arg3,arg4);
10954
10955 wxPyEndAllowThreads(__tstate);
10956 if (PyErr_Occurred()) SWIG_fail;
10957 }
10958 Py_INCREF(Py_None); resultobj = Py_None;
10959 return resultobj;
10960 fail:
10961 return NULL;
10962 }
10963
10964
10965 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10966 PyObject *resultobj;
10967 wxImage *arg1 = (wxImage *) 0 ;
10968 PyObject * obj0 = 0 ;
10969 char *kwnames[] = {
10970 (char *) "self", NULL
10971 };
10972
10973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10975 if (SWIG_arg_fail(1)) SWIG_fail;
10976 {
10977 PyThreadState* __tstate = wxPyBeginAllowThreads();
10978 (arg1)->Destroy();
10979
10980 wxPyEndAllowThreads(__tstate);
10981 if (PyErr_Occurred()) SWIG_fail;
10982 }
10983 Py_INCREF(Py_None); resultobj = Py_None;
10984 return resultobj;
10985 fail:
10986 return NULL;
10987 }
10988
10989
10990 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10991 PyObject *resultobj;
10992 wxImage *arg1 = (wxImage *) 0 ;
10993 int arg2 ;
10994 int arg3 ;
10995 SwigValueWrapper<wxImage > result;
10996 PyObject * obj0 = 0 ;
10997 PyObject * obj1 = 0 ;
10998 PyObject * obj2 = 0 ;
10999 char *kwnames[] = {
11000 (char *) "self",(char *) "width",(char *) "height", NULL
11001 };
11002
11003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11005 if (SWIG_arg_fail(1)) SWIG_fail;
11006 {
11007 arg2 = (int)(SWIG_As_int(obj1));
11008 if (SWIG_arg_fail(2)) SWIG_fail;
11009 }
11010 {
11011 arg3 = (int)(SWIG_As_int(obj2));
11012 if (SWIG_arg_fail(3)) SWIG_fail;
11013 }
11014 {
11015 PyThreadState* __tstate = wxPyBeginAllowThreads();
11016 result = (arg1)->Scale(arg2,arg3);
11017
11018 wxPyEndAllowThreads(__tstate);
11019 if (PyErr_Occurred()) SWIG_fail;
11020 }
11021 {
11022 wxImage * resultptr;
11023 resultptr = new wxImage((wxImage &)(result));
11024 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11025 }
11026 return resultobj;
11027 fail:
11028 return NULL;
11029 }
11030
11031
11032 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11033 PyObject *resultobj;
11034 wxImage *arg1 = (wxImage *) 0 ;
11035 int arg2 ;
11036 int arg3 ;
11037 SwigValueWrapper<wxImage > result;
11038 PyObject * obj0 = 0 ;
11039 PyObject * obj1 = 0 ;
11040 PyObject * obj2 = 0 ;
11041 char *kwnames[] = {
11042 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11043 };
11044
11045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11047 if (SWIG_arg_fail(1)) SWIG_fail;
11048 {
11049 arg2 = (int)(SWIG_As_int(obj1));
11050 if (SWIG_arg_fail(2)) SWIG_fail;
11051 }
11052 {
11053 arg3 = (int)(SWIG_As_int(obj2));
11054 if (SWIG_arg_fail(3)) SWIG_fail;
11055 }
11056 {
11057 PyThreadState* __tstate = wxPyBeginAllowThreads();
11058 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11059
11060 wxPyEndAllowThreads(__tstate);
11061 if (PyErr_Occurred()) SWIG_fail;
11062 }
11063 {
11064 wxImage * resultptr;
11065 resultptr = new wxImage((wxImage &)(result));
11066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11067 }
11068 return resultobj;
11069 fail:
11070 return NULL;
11071 }
11072
11073
11074 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11075 PyObject *resultobj;
11076 wxImage *arg1 = (wxImage *) 0 ;
11077 int arg2 ;
11078 int arg3 ;
11079 wxImage *result;
11080 PyObject * obj0 = 0 ;
11081 PyObject * obj1 = 0 ;
11082 PyObject * obj2 = 0 ;
11083 char *kwnames[] = {
11084 (char *) "self",(char *) "width",(char *) "height", NULL
11085 };
11086
11087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11089 if (SWIG_arg_fail(1)) SWIG_fail;
11090 {
11091 arg2 = (int)(SWIG_As_int(obj1));
11092 if (SWIG_arg_fail(2)) SWIG_fail;
11093 }
11094 {
11095 arg3 = (int)(SWIG_As_int(obj2));
11096 if (SWIG_arg_fail(3)) SWIG_fail;
11097 }
11098 {
11099 PyThreadState* __tstate = wxPyBeginAllowThreads();
11100 {
11101 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11102 result = (wxImage *) &_result_ref;
11103 }
11104
11105 wxPyEndAllowThreads(__tstate);
11106 if (PyErr_Occurred()) SWIG_fail;
11107 }
11108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11109 return resultobj;
11110 fail:
11111 return NULL;
11112 }
11113
11114
11115 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11116 PyObject *resultobj;
11117 wxImage *arg1 = (wxImage *) 0 ;
11118 wxSize *arg2 = 0 ;
11119 wxPoint *arg3 = 0 ;
11120 int arg4 = (int) -1 ;
11121 int arg5 = (int) -1 ;
11122 int arg6 = (int) -1 ;
11123 wxImage *result;
11124 wxSize temp2 ;
11125 wxPoint temp3 ;
11126 PyObject * obj0 = 0 ;
11127 PyObject * obj1 = 0 ;
11128 PyObject * obj2 = 0 ;
11129 PyObject * obj3 = 0 ;
11130 PyObject * obj4 = 0 ;
11131 PyObject * obj5 = 0 ;
11132 char *kwnames[] = {
11133 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11134 };
11135
11136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11138 if (SWIG_arg_fail(1)) SWIG_fail;
11139 {
11140 arg2 = &temp2;
11141 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11142 }
11143 {
11144 arg3 = &temp3;
11145 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11146 }
11147 if (obj3) {
11148 {
11149 arg4 = (int)(SWIG_As_int(obj3));
11150 if (SWIG_arg_fail(4)) SWIG_fail;
11151 }
11152 }
11153 if (obj4) {
11154 {
11155 arg5 = (int)(SWIG_As_int(obj4));
11156 if (SWIG_arg_fail(5)) SWIG_fail;
11157 }
11158 }
11159 if (obj5) {
11160 {
11161 arg6 = (int)(SWIG_As_int(obj5));
11162 if (SWIG_arg_fail(6)) SWIG_fail;
11163 }
11164 }
11165 {
11166 PyThreadState* __tstate = wxPyBeginAllowThreads();
11167 {
11168 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11169 result = (wxImage *) &_result_ref;
11170 }
11171
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11176 return resultobj;
11177 fail:
11178 return NULL;
11179 }
11180
11181
11182 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11183 PyObject *resultobj;
11184 wxImage *arg1 = (wxImage *) 0 ;
11185 int arg2 ;
11186 int arg3 ;
11187 byte arg4 ;
11188 byte arg5 ;
11189 byte arg6 ;
11190 PyObject * obj0 = 0 ;
11191 PyObject * obj1 = 0 ;
11192 PyObject * obj2 = 0 ;
11193 PyObject * obj3 = 0 ;
11194 PyObject * obj4 = 0 ;
11195 PyObject * obj5 = 0 ;
11196 char *kwnames[] = {
11197 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11198 };
11199
11200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11202 if (SWIG_arg_fail(1)) SWIG_fail;
11203 {
11204 arg2 = (int)(SWIG_As_int(obj1));
11205 if (SWIG_arg_fail(2)) SWIG_fail;
11206 }
11207 {
11208 arg3 = (int)(SWIG_As_int(obj2));
11209 if (SWIG_arg_fail(3)) SWIG_fail;
11210 }
11211 {
11212 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11213 if (SWIG_arg_fail(4)) SWIG_fail;
11214 }
11215 {
11216 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11217 if (SWIG_arg_fail(5)) SWIG_fail;
11218 }
11219 {
11220 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
11221 if (SWIG_arg_fail(6)) SWIG_fail;
11222 }
11223 {
11224 PyThreadState* __tstate = wxPyBeginAllowThreads();
11225 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11226
11227 wxPyEndAllowThreads(__tstate);
11228 if (PyErr_Occurred()) SWIG_fail;
11229 }
11230 Py_INCREF(Py_None); resultobj = Py_None;
11231 return resultobj;
11232 fail:
11233 return NULL;
11234 }
11235
11236
11237 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11238 PyObject *resultobj;
11239 wxImage *arg1 = (wxImage *) 0 ;
11240 wxRect *arg2 = 0 ;
11241 byte arg3 ;
11242 byte arg4 ;
11243 byte arg5 ;
11244 wxRect temp2 ;
11245 PyObject * obj0 = 0 ;
11246 PyObject * obj1 = 0 ;
11247 PyObject * obj2 = 0 ;
11248 PyObject * obj3 = 0 ;
11249 PyObject * obj4 = 0 ;
11250 char *kwnames[] = {
11251 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11252 };
11253
11254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11256 if (SWIG_arg_fail(1)) SWIG_fail;
11257 {
11258 arg2 = &temp2;
11259 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11260 }
11261 {
11262 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11263 if (SWIG_arg_fail(3)) SWIG_fail;
11264 }
11265 {
11266 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11267 if (SWIG_arg_fail(4)) SWIG_fail;
11268 }
11269 {
11270 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11271 if (SWIG_arg_fail(5)) SWIG_fail;
11272 }
11273 {
11274 PyThreadState* __tstate = wxPyBeginAllowThreads();
11275 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11276
11277 wxPyEndAllowThreads(__tstate);
11278 if (PyErr_Occurred()) SWIG_fail;
11279 }
11280 Py_INCREF(Py_None); resultobj = Py_None;
11281 return resultobj;
11282 fail:
11283 return NULL;
11284 }
11285
11286
11287 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11288 PyObject *resultobj;
11289 wxImage *arg1 = (wxImage *) 0 ;
11290 int arg2 ;
11291 int arg3 ;
11292 byte result;
11293 PyObject * obj0 = 0 ;
11294 PyObject * obj1 = 0 ;
11295 PyObject * obj2 = 0 ;
11296 char *kwnames[] = {
11297 (char *) "self",(char *) "x",(char *) "y", NULL
11298 };
11299
11300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11302 if (SWIG_arg_fail(1)) SWIG_fail;
11303 {
11304 arg2 = (int)(SWIG_As_int(obj1));
11305 if (SWIG_arg_fail(2)) SWIG_fail;
11306 }
11307 {
11308 arg3 = (int)(SWIG_As_int(obj2));
11309 if (SWIG_arg_fail(3)) SWIG_fail;
11310 }
11311 {
11312 PyThreadState* __tstate = wxPyBeginAllowThreads();
11313 result = (byte)(arg1)->GetRed(arg2,arg3);
11314
11315 wxPyEndAllowThreads(__tstate);
11316 if (PyErr_Occurred()) SWIG_fail;
11317 }
11318 {
11319 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11320 }
11321 return resultobj;
11322 fail:
11323 return NULL;
11324 }
11325
11326
11327 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11328 PyObject *resultobj;
11329 wxImage *arg1 = (wxImage *) 0 ;
11330 int arg2 ;
11331 int arg3 ;
11332 byte result;
11333 PyObject * obj0 = 0 ;
11334 PyObject * obj1 = 0 ;
11335 PyObject * obj2 = 0 ;
11336 char *kwnames[] = {
11337 (char *) "self",(char *) "x",(char *) "y", NULL
11338 };
11339
11340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11342 if (SWIG_arg_fail(1)) SWIG_fail;
11343 {
11344 arg2 = (int)(SWIG_As_int(obj1));
11345 if (SWIG_arg_fail(2)) SWIG_fail;
11346 }
11347 {
11348 arg3 = (int)(SWIG_As_int(obj2));
11349 if (SWIG_arg_fail(3)) SWIG_fail;
11350 }
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 result = (byte)(arg1)->GetGreen(arg2,arg3);
11354
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 {
11359 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11360 }
11361 return resultobj;
11362 fail:
11363 return NULL;
11364 }
11365
11366
11367 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11368 PyObject *resultobj;
11369 wxImage *arg1 = (wxImage *) 0 ;
11370 int arg2 ;
11371 int arg3 ;
11372 byte result;
11373 PyObject * obj0 = 0 ;
11374 PyObject * obj1 = 0 ;
11375 PyObject * obj2 = 0 ;
11376 char *kwnames[] = {
11377 (char *) "self",(char *) "x",(char *) "y", NULL
11378 };
11379
11380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11382 if (SWIG_arg_fail(1)) SWIG_fail;
11383 {
11384 arg2 = (int)(SWIG_As_int(obj1));
11385 if (SWIG_arg_fail(2)) SWIG_fail;
11386 }
11387 {
11388 arg3 = (int)(SWIG_As_int(obj2));
11389 if (SWIG_arg_fail(3)) SWIG_fail;
11390 }
11391 {
11392 PyThreadState* __tstate = wxPyBeginAllowThreads();
11393 result = (byte)(arg1)->GetBlue(arg2,arg3);
11394
11395 wxPyEndAllowThreads(__tstate);
11396 if (PyErr_Occurred()) SWIG_fail;
11397 }
11398 {
11399 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11400 }
11401 return resultobj;
11402 fail:
11403 return NULL;
11404 }
11405
11406
11407 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11408 PyObject *resultobj;
11409 wxImage *arg1 = (wxImage *) 0 ;
11410 int arg2 ;
11411 int arg3 ;
11412 byte arg4 ;
11413 PyObject * obj0 = 0 ;
11414 PyObject * obj1 = 0 ;
11415 PyObject * obj2 = 0 ;
11416 PyObject * obj3 = 0 ;
11417 char *kwnames[] = {
11418 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11419 };
11420
11421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11423 if (SWIG_arg_fail(1)) SWIG_fail;
11424 {
11425 arg2 = (int)(SWIG_As_int(obj1));
11426 if (SWIG_arg_fail(2)) SWIG_fail;
11427 }
11428 {
11429 arg3 = (int)(SWIG_As_int(obj2));
11430 if (SWIG_arg_fail(3)) SWIG_fail;
11431 }
11432 {
11433 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11434 if (SWIG_arg_fail(4)) SWIG_fail;
11435 }
11436 {
11437 PyThreadState* __tstate = wxPyBeginAllowThreads();
11438 (arg1)->SetAlpha(arg2,arg3,arg4);
11439
11440 wxPyEndAllowThreads(__tstate);
11441 if (PyErr_Occurred()) SWIG_fail;
11442 }
11443 Py_INCREF(Py_None); resultobj = Py_None;
11444 return resultobj;
11445 fail:
11446 return NULL;
11447 }
11448
11449
11450 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11451 PyObject *resultobj;
11452 wxImage *arg1 = (wxImage *) 0 ;
11453 int arg2 ;
11454 int arg3 ;
11455 byte result;
11456 PyObject * obj0 = 0 ;
11457 PyObject * obj1 = 0 ;
11458 PyObject * obj2 = 0 ;
11459 char *kwnames[] = {
11460 (char *) "self",(char *) "x",(char *) "y", NULL
11461 };
11462
11463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11465 if (SWIG_arg_fail(1)) SWIG_fail;
11466 {
11467 arg2 = (int)(SWIG_As_int(obj1));
11468 if (SWIG_arg_fail(2)) SWIG_fail;
11469 }
11470 {
11471 arg3 = (int)(SWIG_As_int(obj2));
11472 if (SWIG_arg_fail(3)) SWIG_fail;
11473 }
11474 {
11475 PyThreadState* __tstate = wxPyBeginAllowThreads();
11476 result = (byte)(arg1)->GetAlpha(arg2,arg3);
11477
11478 wxPyEndAllowThreads(__tstate);
11479 if (PyErr_Occurred()) SWIG_fail;
11480 }
11481 {
11482 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11483 }
11484 return resultobj;
11485 fail:
11486 return NULL;
11487 }
11488
11489
11490 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11491 PyObject *resultobj;
11492 wxImage *arg1 = (wxImage *) 0 ;
11493 bool result;
11494 PyObject * obj0 = 0 ;
11495 char *kwnames[] = {
11496 (char *) "self", NULL
11497 };
11498
11499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11501 if (SWIG_arg_fail(1)) SWIG_fail;
11502 {
11503 PyThreadState* __tstate = wxPyBeginAllowThreads();
11504 result = (bool)(arg1)->HasAlpha();
11505
11506 wxPyEndAllowThreads(__tstate);
11507 if (PyErr_Occurred()) SWIG_fail;
11508 }
11509 {
11510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11511 }
11512 return resultobj;
11513 fail:
11514 return NULL;
11515 }
11516
11517
11518 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj;
11520 wxImage *arg1 = (wxImage *) 0 ;
11521 PyObject * obj0 = 0 ;
11522 char *kwnames[] = {
11523 (char *) "self", NULL
11524 };
11525
11526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11528 if (SWIG_arg_fail(1)) SWIG_fail;
11529 {
11530 PyThreadState* __tstate = wxPyBeginAllowThreads();
11531 (arg1)->InitAlpha();
11532
11533 wxPyEndAllowThreads(__tstate);
11534 if (PyErr_Occurred()) SWIG_fail;
11535 }
11536 Py_INCREF(Py_None); resultobj = Py_None;
11537 return resultobj;
11538 fail:
11539 return NULL;
11540 }
11541
11542
11543 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11544 PyObject *resultobj;
11545 wxImage *arg1 = (wxImage *) 0 ;
11546 int arg2 ;
11547 int arg3 ;
11548 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11549 bool result;
11550 PyObject * obj0 = 0 ;
11551 PyObject * obj1 = 0 ;
11552 PyObject * obj2 = 0 ;
11553 PyObject * obj3 = 0 ;
11554 char *kwnames[] = {
11555 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11556 };
11557
11558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11560 if (SWIG_arg_fail(1)) SWIG_fail;
11561 {
11562 arg2 = (int)(SWIG_As_int(obj1));
11563 if (SWIG_arg_fail(2)) SWIG_fail;
11564 }
11565 {
11566 arg3 = (int)(SWIG_As_int(obj2));
11567 if (SWIG_arg_fail(3)) SWIG_fail;
11568 }
11569 if (obj3) {
11570 {
11571 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11572 if (SWIG_arg_fail(4)) SWIG_fail;
11573 }
11574 }
11575 {
11576 PyThreadState* __tstate = wxPyBeginAllowThreads();
11577 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11578
11579 wxPyEndAllowThreads(__tstate);
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 {
11583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11584 }
11585 return resultobj;
11586 fail:
11587 return NULL;
11588 }
11589
11590
11591 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11592 PyObject *resultobj;
11593 wxImage *arg1 = (wxImage *) 0 ;
11594 byte *arg2 = (byte *) 0 ;
11595 byte *arg3 = (byte *) 0 ;
11596 byte *arg4 = (byte *) 0 ;
11597 byte arg5 = (byte) 0 ;
11598 byte arg6 = (byte) 0 ;
11599 byte arg7 = (byte) 0 ;
11600 bool result;
11601 byte temp2 ;
11602 int res2 = 0 ;
11603 byte temp3 ;
11604 int res3 = 0 ;
11605 byte temp4 ;
11606 int res4 = 0 ;
11607 PyObject * obj0 = 0 ;
11608 PyObject * obj1 = 0 ;
11609 PyObject * obj2 = 0 ;
11610 PyObject * obj3 = 0 ;
11611 char *kwnames[] = {
11612 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11613 };
11614
11615 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11616 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11617 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11620 if (SWIG_arg_fail(1)) SWIG_fail;
11621 if (obj1) {
11622 {
11623 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11624 if (SWIG_arg_fail(5)) SWIG_fail;
11625 }
11626 }
11627 if (obj2) {
11628 {
11629 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11630 if (SWIG_arg_fail(6)) SWIG_fail;
11631 }
11632 }
11633 if (obj3) {
11634 {
11635 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11636 if (SWIG_arg_fail(7)) SWIG_fail;
11637 }
11638 }
11639 {
11640 PyThreadState* __tstate = wxPyBeginAllowThreads();
11641 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11642
11643 wxPyEndAllowThreads(__tstate);
11644 if (PyErr_Occurred()) SWIG_fail;
11645 }
11646 {
11647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11648 }
11649 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11650 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11651 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11652 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11653 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11654 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11662 PyObject *resultobj;
11663 wxImage *arg1 = (wxImage *) 0 ;
11664 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11665 bool result;
11666 PyObject * obj0 = 0 ;
11667 PyObject * obj1 = 0 ;
11668 char *kwnames[] = {
11669 (char *) "self",(char *) "threshold", NULL
11670 };
11671
11672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11674 if (SWIG_arg_fail(1)) SWIG_fail;
11675 if (obj1) {
11676 {
11677 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11678 if (SWIG_arg_fail(2)) SWIG_fail;
11679 }
11680 }
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11684
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 {
11689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11690 }
11691 return resultobj;
11692 fail:
11693 return NULL;
11694 }
11695
11696
11697 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11698 PyObject *resultobj;
11699 wxImage *arg1 = (wxImage *) 0 ;
11700 byte arg2 ;
11701 byte arg3 ;
11702 byte arg4 ;
11703 bool result;
11704 PyObject * obj0 = 0 ;
11705 PyObject * obj1 = 0 ;
11706 PyObject * obj2 = 0 ;
11707 PyObject * obj3 = 0 ;
11708 char *kwnames[] = {
11709 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11710 };
11711
11712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11714 if (SWIG_arg_fail(1)) SWIG_fail;
11715 {
11716 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11717 if (SWIG_arg_fail(2)) SWIG_fail;
11718 }
11719 {
11720 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11721 if (SWIG_arg_fail(3)) SWIG_fail;
11722 }
11723 {
11724 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11725 if (SWIG_arg_fail(4)) SWIG_fail;
11726 }
11727 {
11728 PyThreadState* __tstate = wxPyBeginAllowThreads();
11729 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11730
11731 wxPyEndAllowThreads(__tstate);
11732 if (PyErr_Occurred()) SWIG_fail;
11733 }
11734 {
11735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11736 }
11737 return resultobj;
11738 fail:
11739 return NULL;
11740 }
11741
11742
11743 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11744 PyObject *resultobj;
11745 wxImage *arg1 = (wxImage *) 0 ;
11746 wxImage *arg2 = 0 ;
11747 byte arg3 ;
11748 byte arg4 ;
11749 byte arg5 ;
11750 bool result;
11751 PyObject * obj0 = 0 ;
11752 PyObject * obj1 = 0 ;
11753 PyObject * obj2 = 0 ;
11754 PyObject * obj3 = 0 ;
11755 PyObject * obj4 = 0 ;
11756 char *kwnames[] = {
11757 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11758 };
11759
11760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11762 if (SWIG_arg_fail(1)) SWIG_fail;
11763 {
11764 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11765 if (SWIG_arg_fail(2)) SWIG_fail;
11766 if (arg2 == NULL) {
11767 SWIG_null_ref("wxImage");
11768 }
11769 if (SWIG_arg_fail(2)) SWIG_fail;
11770 }
11771 {
11772 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11773 if (SWIG_arg_fail(3)) SWIG_fail;
11774 }
11775 {
11776 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11777 if (SWIG_arg_fail(4)) SWIG_fail;
11778 }
11779 {
11780 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11781 if (SWIG_arg_fail(5)) SWIG_fail;
11782 }
11783 {
11784 PyThreadState* __tstate = wxPyBeginAllowThreads();
11785 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11786
11787 wxPyEndAllowThreads(__tstate);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 {
11791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11792 }
11793 return resultobj;
11794 fail:
11795 return NULL;
11796 }
11797
11798
11799 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11800 PyObject *resultobj;
11801 wxString *arg1 = 0 ;
11802 bool result;
11803 bool temp1 = false ;
11804 PyObject * obj0 = 0 ;
11805 char *kwnames[] = {
11806 (char *) "filename", NULL
11807 };
11808
11809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11810 {
11811 arg1 = wxString_in_helper(obj0);
11812 if (arg1 == NULL) SWIG_fail;
11813 temp1 = true;
11814 }
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11818
11819 wxPyEndAllowThreads(__tstate);
11820 if (PyErr_Occurred()) SWIG_fail;
11821 }
11822 {
11823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11824 }
11825 {
11826 if (temp1)
11827 delete arg1;
11828 }
11829 return resultobj;
11830 fail:
11831 {
11832 if (temp1)
11833 delete arg1;
11834 }
11835 return NULL;
11836 }
11837
11838
11839 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11840 PyObject *resultobj;
11841 wxString *arg1 = 0 ;
11842 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11843 int result;
11844 bool temp1 = false ;
11845 PyObject * obj0 = 0 ;
11846 PyObject * obj1 = 0 ;
11847 char *kwnames[] = {
11848 (char *) "filename",(char *) "type", NULL
11849 };
11850
11851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11852 {
11853 arg1 = wxString_in_helper(obj0);
11854 if (arg1 == NULL) SWIG_fail;
11855 temp1 = true;
11856 }
11857 if (obj1) {
11858 {
11859 arg2 = (long)(SWIG_As_long(obj1));
11860 if (SWIG_arg_fail(2)) SWIG_fail;
11861 }
11862 }
11863 {
11864 PyThreadState* __tstate = wxPyBeginAllowThreads();
11865 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11866
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 {
11871 resultobj = SWIG_From_int((int)(result));
11872 }
11873 {
11874 if (temp1)
11875 delete arg1;
11876 }
11877 return resultobj;
11878 fail:
11879 {
11880 if (temp1)
11881 delete arg1;
11882 }
11883 return NULL;
11884 }
11885
11886
11887 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11888 PyObject *resultobj;
11889 wxImage *arg1 = (wxImage *) 0 ;
11890 wxString *arg2 = 0 ;
11891 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11892 int arg4 = (int) -1 ;
11893 bool result;
11894 bool temp2 = false ;
11895 PyObject * obj0 = 0 ;
11896 PyObject * obj1 = 0 ;
11897 PyObject * obj2 = 0 ;
11898 PyObject * obj3 = 0 ;
11899 char *kwnames[] = {
11900 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11901 };
11902
11903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11905 if (SWIG_arg_fail(1)) SWIG_fail;
11906 {
11907 arg2 = wxString_in_helper(obj1);
11908 if (arg2 == NULL) SWIG_fail;
11909 temp2 = true;
11910 }
11911 if (obj2) {
11912 {
11913 arg3 = (long)(SWIG_As_long(obj2));
11914 if (SWIG_arg_fail(3)) SWIG_fail;
11915 }
11916 }
11917 if (obj3) {
11918 {
11919 arg4 = (int)(SWIG_As_int(obj3));
11920 if (SWIG_arg_fail(4)) SWIG_fail;
11921 }
11922 }
11923 {
11924 PyThreadState* __tstate = wxPyBeginAllowThreads();
11925 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11926
11927 wxPyEndAllowThreads(__tstate);
11928 if (PyErr_Occurred()) SWIG_fail;
11929 }
11930 {
11931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11932 }
11933 {
11934 if (temp2)
11935 delete arg2;
11936 }
11937 return resultobj;
11938 fail:
11939 {
11940 if (temp2)
11941 delete arg2;
11942 }
11943 return NULL;
11944 }
11945
11946
11947 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj;
11949 wxImage *arg1 = (wxImage *) 0 ;
11950 wxString *arg2 = 0 ;
11951 wxString *arg3 = 0 ;
11952 int arg4 = (int) -1 ;
11953 bool result;
11954 bool temp2 = false ;
11955 bool temp3 = false ;
11956 PyObject * obj0 = 0 ;
11957 PyObject * obj1 = 0 ;
11958 PyObject * obj2 = 0 ;
11959 PyObject * obj3 = 0 ;
11960 char *kwnames[] = {
11961 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11962 };
11963
11964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11966 if (SWIG_arg_fail(1)) SWIG_fail;
11967 {
11968 arg2 = wxString_in_helper(obj1);
11969 if (arg2 == NULL) SWIG_fail;
11970 temp2 = true;
11971 }
11972 {
11973 arg3 = wxString_in_helper(obj2);
11974 if (arg3 == NULL) SWIG_fail;
11975 temp3 = true;
11976 }
11977 if (obj3) {
11978 {
11979 arg4 = (int)(SWIG_As_int(obj3));
11980 if (SWIG_arg_fail(4)) SWIG_fail;
11981 }
11982 }
11983 {
11984 PyThreadState* __tstate = wxPyBeginAllowThreads();
11985 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11986
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 {
11991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11992 }
11993 {
11994 if (temp2)
11995 delete arg2;
11996 }
11997 {
11998 if (temp3)
11999 delete arg3;
12000 }
12001 return resultobj;
12002 fail:
12003 {
12004 if (temp2)
12005 delete arg2;
12006 }
12007 {
12008 if (temp3)
12009 delete arg3;
12010 }
12011 return NULL;
12012 }
12013
12014
12015 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12016 PyObject *resultobj;
12017 wxImage *arg1 = (wxImage *) 0 ;
12018 wxString *arg2 = 0 ;
12019 int arg3 ;
12020 bool result;
12021 bool temp2 = false ;
12022 PyObject * obj0 = 0 ;
12023 PyObject * obj1 = 0 ;
12024 PyObject * obj2 = 0 ;
12025 char *kwnames[] = {
12026 (char *) "self",(char *) "name",(char *) "type", NULL
12027 };
12028
12029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12031 if (SWIG_arg_fail(1)) SWIG_fail;
12032 {
12033 arg2 = wxString_in_helper(obj1);
12034 if (arg2 == NULL) SWIG_fail;
12035 temp2 = true;
12036 }
12037 {
12038 arg3 = (int)(SWIG_As_int(obj2));
12039 if (SWIG_arg_fail(3)) SWIG_fail;
12040 }
12041 {
12042 PyThreadState* __tstate = wxPyBeginAllowThreads();
12043 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12044
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 {
12049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12050 }
12051 {
12052 if (temp2)
12053 delete arg2;
12054 }
12055 return resultobj;
12056 fail:
12057 {
12058 if (temp2)
12059 delete arg2;
12060 }
12061 return NULL;
12062 }
12063
12064
12065 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12066 PyObject *resultobj;
12067 wxImage *arg1 = (wxImage *) 0 ;
12068 wxString *arg2 = 0 ;
12069 wxString *arg3 = 0 ;
12070 bool result;
12071 bool temp2 = false ;
12072 bool temp3 = false ;
12073 PyObject * obj0 = 0 ;
12074 PyObject * obj1 = 0 ;
12075 PyObject * obj2 = 0 ;
12076 char *kwnames[] = {
12077 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12078 };
12079
12080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12082 if (SWIG_arg_fail(1)) SWIG_fail;
12083 {
12084 arg2 = wxString_in_helper(obj1);
12085 if (arg2 == NULL) SWIG_fail;
12086 temp2 = true;
12087 }
12088 {
12089 arg3 = wxString_in_helper(obj2);
12090 if (arg3 == NULL) SWIG_fail;
12091 temp3 = true;
12092 }
12093 {
12094 PyThreadState* __tstate = wxPyBeginAllowThreads();
12095 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12096
12097 wxPyEndAllowThreads(__tstate);
12098 if (PyErr_Occurred()) SWIG_fail;
12099 }
12100 {
12101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12102 }
12103 {
12104 if (temp2)
12105 delete arg2;
12106 }
12107 {
12108 if (temp3)
12109 delete arg3;
12110 }
12111 return resultobj;
12112 fail:
12113 {
12114 if (temp2)
12115 delete arg2;
12116 }
12117 {
12118 if (temp3)
12119 delete arg3;
12120 }
12121 return NULL;
12122 }
12123
12124
12125 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12126 PyObject *resultobj;
12127 wxInputStream *arg1 = 0 ;
12128 bool result;
12129 wxPyInputStream *temp1 ;
12130 bool created1 ;
12131 PyObject * obj0 = 0 ;
12132 char *kwnames[] = {
12133 (char *) "stream", NULL
12134 };
12135
12136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12137 {
12138 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12139 arg1 = temp1->m_wxis;
12140 created1 = false;
12141 } else {
12142 PyErr_Clear(); // clear the failure of the wxPyConvert above
12143 arg1 = wxPyCBInputStream_create(obj0, false);
12144 if (arg1 == NULL) {
12145 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12146 SWIG_fail;
12147 }
12148 created1 = true;
12149 }
12150 }
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 result = (bool)wxImage::CanRead(*arg1);
12154
12155 wxPyEndAllowThreads(__tstate);
12156 if (PyErr_Occurred()) SWIG_fail;
12157 }
12158 {
12159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12160 }
12161 {
12162 if (created1) delete arg1;
12163 }
12164 return resultobj;
12165 fail:
12166 {
12167 if (created1) delete arg1;
12168 }
12169 return NULL;
12170 }
12171
12172
12173 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12174 PyObject *resultobj;
12175 wxImage *arg1 = (wxImage *) 0 ;
12176 wxInputStream *arg2 = 0 ;
12177 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12178 int arg4 = (int) -1 ;
12179 bool result;
12180 wxPyInputStream *temp2 ;
12181 bool created2 ;
12182 PyObject * obj0 = 0 ;
12183 PyObject * obj1 = 0 ;
12184 PyObject * obj2 = 0 ;
12185 PyObject * obj3 = 0 ;
12186 char *kwnames[] = {
12187 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12188 };
12189
12190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12192 if (SWIG_arg_fail(1)) SWIG_fail;
12193 {
12194 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12195 arg2 = temp2->m_wxis;
12196 created2 = false;
12197 } else {
12198 PyErr_Clear(); // clear the failure of the wxPyConvert above
12199 arg2 = wxPyCBInputStream_create(obj1, false);
12200 if (arg2 == NULL) {
12201 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12202 SWIG_fail;
12203 }
12204 created2 = true;
12205 }
12206 }
12207 if (obj2) {
12208 {
12209 arg3 = (long)(SWIG_As_long(obj2));
12210 if (SWIG_arg_fail(3)) SWIG_fail;
12211 }
12212 }
12213 if (obj3) {
12214 {
12215 arg4 = (int)(SWIG_As_int(obj3));
12216 if (SWIG_arg_fail(4)) SWIG_fail;
12217 }
12218 }
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12222
12223 wxPyEndAllowThreads(__tstate);
12224 if (PyErr_Occurred()) SWIG_fail;
12225 }
12226 {
12227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12228 }
12229 {
12230 if (created2) delete arg2;
12231 }
12232 return resultobj;
12233 fail:
12234 {
12235 if (created2) delete arg2;
12236 }
12237 return NULL;
12238 }
12239
12240
12241 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12242 PyObject *resultobj;
12243 wxImage *arg1 = (wxImage *) 0 ;
12244 wxInputStream *arg2 = 0 ;
12245 wxString *arg3 = 0 ;
12246 int arg4 = (int) -1 ;
12247 bool result;
12248 wxPyInputStream *temp2 ;
12249 bool created2 ;
12250 bool temp3 = false ;
12251 PyObject * obj0 = 0 ;
12252 PyObject * obj1 = 0 ;
12253 PyObject * obj2 = 0 ;
12254 PyObject * obj3 = 0 ;
12255 char *kwnames[] = {
12256 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12257 };
12258
12259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12261 if (SWIG_arg_fail(1)) SWIG_fail;
12262 {
12263 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12264 arg2 = temp2->m_wxis;
12265 created2 = false;
12266 } else {
12267 PyErr_Clear(); // clear the failure of the wxPyConvert above
12268 arg2 = wxPyCBInputStream_create(obj1, false);
12269 if (arg2 == NULL) {
12270 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12271 SWIG_fail;
12272 }
12273 created2 = true;
12274 }
12275 }
12276 {
12277 arg3 = wxString_in_helper(obj2);
12278 if (arg3 == NULL) SWIG_fail;
12279 temp3 = true;
12280 }
12281 if (obj3) {
12282 {
12283 arg4 = (int)(SWIG_As_int(obj3));
12284 if (SWIG_arg_fail(4)) SWIG_fail;
12285 }
12286 }
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12290
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 {
12295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12296 }
12297 {
12298 if (created2) delete arg2;
12299 }
12300 {
12301 if (temp3)
12302 delete arg3;
12303 }
12304 return resultobj;
12305 fail:
12306 {
12307 if (created2) delete arg2;
12308 }
12309 {
12310 if (temp3)
12311 delete arg3;
12312 }
12313 return NULL;
12314 }
12315
12316
12317 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12318 PyObject *resultobj;
12319 wxImage *arg1 = (wxImage *) 0 ;
12320 bool result;
12321 PyObject * obj0 = 0 ;
12322 char *kwnames[] = {
12323 (char *) "self", NULL
12324 };
12325
12326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12328 if (SWIG_arg_fail(1)) SWIG_fail;
12329 {
12330 PyThreadState* __tstate = wxPyBeginAllowThreads();
12331 result = (bool)(arg1)->Ok();
12332
12333 wxPyEndAllowThreads(__tstate);
12334 if (PyErr_Occurred()) SWIG_fail;
12335 }
12336 {
12337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12338 }
12339 return resultobj;
12340 fail:
12341 return NULL;
12342 }
12343
12344
12345 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12346 PyObject *resultobj;
12347 wxImage *arg1 = (wxImage *) 0 ;
12348 int result;
12349 PyObject * obj0 = 0 ;
12350 char *kwnames[] = {
12351 (char *) "self", NULL
12352 };
12353
12354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12356 if (SWIG_arg_fail(1)) SWIG_fail;
12357 {
12358 PyThreadState* __tstate = wxPyBeginAllowThreads();
12359 result = (int)(arg1)->GetWidth();
12360
12361 wxPyEndAllowThreads(__tstate);
12362 if (PyErr_Occurred()) SWIG_fail;
12363 }
12364 {
12365 resultobj = SWIG_From_int((int)(result));
12366 }
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12374 PyObject *resultobj;
12375 wxImage *arg1 = (wxImage *) 0 ;
12376 int result;
12377 PyObject * obj0 = 0 ;
12378 char *kwnames[] = {
12379 (char *) "self", NULL
12380 };
12381
12382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12384 if (SWIG_arg_fail(1)) SWIG_fail;
12385 {
12386 PyThreadState* __tstate = wxPyBeginAllowThreads();
12387 result = (int)(arg1)->GetHeight();
12388
12389 wxPyEndAllowThreads(__tstate);
12390 if (PyErr_Occurred()) SWIG_fail;
12391 }
12392 {
12393 resultobj = SWIG_From_int((int)(result));
12394 }
12395 return resultobj;
12396 fail:
12397 return NULL;
12398 }
12399
12400
12401 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12402 PyObject *resultobj;
12403 wxImage *arg1 = (wxImage *) 0 ;
12404 wxSize result;
12405 PyObject * obj0 = 0 ;
12406 char *kwnames[] = {
12407 (char *) "self", NULL
12408 };
12409
12410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12412 if (SWIG_arg_fail(1)) SWIG_fail;
12413 {
12414 PyThreadState* __tstate = wxPyBeginAllowThreads();
12415 result = wxImage_GetSize(arg1);
12416
12417 wxPyEndAllowThreads(__tstate);
12418 if (PyErr_Occurred()) SWIG_fail;
12419 }
12420 {
12421 wxSize * resultptr;
12422 resultptr = new wxSize((wxSize &)(result));
12423 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12424 }
12425 return resultobj;
12426 fail:
12427 return NULL;
12428 }
12429
12430
12431 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12432 PyObject *resultobj;
12433 wxImage *arg1 = (wxImage *) 0 ;
12434 wxRect *arg2 = 0 ;
12435 SwigValueWrapper<wxImage > result;
12436 wxRect temp2 ;
12437 PyObject * obj0 = 0 ;
12438 PyObject * obj1 = 0 ;
12439 char *kwnames[] = {
12440 (char *) "self",(char *) "rect", NULL
12441 };
12442
12443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12445 if (SWIG_arg_fail(1)) SWIG_fail;
12446 {
12447 arg2 = &temp2;
12448 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12449 }
12450 {
12451 PyThreadState* __tstate = wxPyBeginAllowThreads();
12452 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12453
12454 wxPyEndAllowThreads(__tstate);
12455 if (PyErr_Occurred()) SWIG_fail;
12456 }
12457 {
12458 wxImage * resultptr;
12459 resultptr = new wxImage((wxImage &)(result));
12460 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12461 }
12462 return resultobj;
12463 fail:
12464 return NULL;
12465 }
12466
12467
12468 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12469 PyObject *resultobj;
12470 wxImage *arg1 = (wxImage *) 0 ;
12471 wxSize *arg2 = 0 ;
12472 wxPoint *arg3 = 0 ;
12473 int arg4 = (int) -1 ;
12474 int arg5 = (int) -1 ;
12475 int arg6 = (int) -1 ;
12476 SwigValueWrapper<wxImage > result;
12477 wxSize temp2 ;
12478 wxPoint temp3 ;
12479 PyObject * obj0 = 0 ;
12480 PyObject * obj1 = 0 ;
12481 PyObject * obj2 = 0 ;
12482 PyObject * obj3 = 0 ;
12483 PyObject * obj4 = 0 ;
12484 PyObject * obj5 = 0 ;
12485 char *kwnames[] = {
12486 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12487 };
12488
12489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12491 if (SWIG_arg_fail(1)) SWIG_fail;
12492 {
12493 arg2 = &temp2;
12494 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12495 }
12496 {
12497 arg3 = &temp3;
12498 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12499 }
12500 if (obj3) {
12501 {
12502 arg4 = (int)(SWIG_As_int(obj3));
12503 if (SWIG_arg_fail(4)) SWIG_fail;
12504 }
12505 }
12506 if (obj4) {
12507 {
12508 arg5 = (int)(SWIG_As_int(obj4));
12509 if (SWIG_arg_fail(5)) SWIG_fail;
12510 }
12511 }
12512 if (obj5) {
12513 {
12514 arg6 = (int)(SWIG_As_int(obj5));
12515 if (SWIG_arg_fail(6)) SWIG_fail;
12516 }
12517 }
12518 {
12519 PyThreadState* __tstate = wxPyBeginAllowThreads();
12520 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12521
12522 wxPyEndAllowThreads(__tstate);
12523 if (PyErr_Occurred()) SWIG_fail;
12524 }
12525 {
12526 wxImage * resultptr;
12527 resultptr = new wxImage((wxImage &)(result));
12528 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12529 }
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12537 PyObject *resultobj;
12538 wxImage *arg1 = (wxImage *) 0 ;
12539 SwigValueWrapper<wxImage > result;
12540 PyObject * obj0 = 0 ;
12541 char *kwnames[] = {
12542 (char *) "self", NULL
12543 };
12544
12545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12547 if (SWIG_arg_fail(1)) SWIG_fail;
12548 {
12549 PyThreadState* __tstate = wxPyBeginAllowThreads();
12550 result = (arg1)->Copy();
12551
12552 wxPyEndAllowThreads(__tstate);
12553 if (PyErr_Occurred()) SWIG_fail;
12554 }
12555 {
12556 wxImage * resultptr;
12557 resultptr = new wxImage((wxImage &)(result));
12558 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12559 }
12560 return resultobj;
12561 fail:
12562 return NULL;
12563 }
12564
12565
12566 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12567 PyObject *resultobj;
12568 wxImage *arg1 = (wxImage *) 0 ;
12569 wxImage *arg2 = 0 ;
12570 int arg3 ;
12571 int arg4 ;
12572 PyObject * obj0 = 0 ;
12573 PyObject * obj1 = 0 ;
12574 PyObject * obj2 = 0 ;
12575 PyObject * obj3 = 0 ;
12576 char *kwnames[] = {
12577 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12578 };
12579
12580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12582 if (SWIG_arg_fail(1)) SWIG_fail;
12583 {
12584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12585 if (SWIG_arg_fail(2)) SWIG_fail;
12586 if (arg2 == NULL) {
12587 SWIG_null_ref("wxImage");
12588 }
12589 if (SWIG_arg_fail(2)) SWIG_fail;
12590 }
12591 {
12592 arg3 = (int)(SWIG_As_int(obj2));
12593 if (SWIG_arg_fail(3)) SWIG_fail;
12594 }
12595 {
12596 arg4 = (int)(SWIG_As_int(obj3));
12597 if (SWIG_arg_fail(4)) SWIG_fail;
12598 }
12599 {
12600 PyThreadState* __tstate = wxPyBeginAllowThreads();
12601 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12602
12603 wxPyEndAllowThreads(__tstate);
12604 if (PyErr_Occurred()) SWIG_fail;
12605 }
12606 Py_INCREF(Py_None); resultobj = Py_None;
12607 return resultobj;
12608 fail:
12609 return NULL;
12610 }
12611
12612
12613 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12614 PyObject *resultobj;
12615 wxImage *arg1 = (wxImage *) 0 ;
12616 PyObject *result;
12617 PyObject * obj0 = 0 ;
12618 char *kwnames[] = {
12619 (char *) "self", NULL
12620 };
12621
12622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12624 if (SWIG_arg_fail(1)) SWIG_fail;
12625 {
12626 PyThreadState* __tstate = wxPyBeginAllowThreads();
12627 result = (PyObject *)wxImage_GetData(arg1);
12628
12629 wxPyEndAllowThreads(__tstate);
12630 if (PyErr_Occurred()) SWIG_fail;
12631 }
12632 resultobj = result;
12633 return resultobj;
12634 fail:
12635 return NULL;
12636 }
12637
12638
12639 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj;
12641 wxImage *arg1 = (wxImage *) 0 ;
12642 buffer arg2 ;
12643 int arg3 ;
12644 PyObject * obj0 = 0 ;
12645 PyObject * obj1 = 0 ;
12646 char *kwnames[] = {
12647 (char *) "self",(char *) "data", NULL
12648 };
12649
12650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12652 if (SWIG_arg_fail(1)) SWIG_fail;
12653 {
12654 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12655 }
12656 {
12657 PyThreadState* __tstate = wxPyBeginAllowThreads();
12658 wxImage_SetData(arg1,arg2,arg3);
12659
12660 wxPyEndAllowThreads(__tstate);
12661 if (PyErr_Occurred()) SWIG_fail;
12662 }
12663 Py_INCREF(Py_None); resultobj = Py_None;
12664 return resultobj;
12665 fail:
12666 return NULL;
12667 }
12668
12669
12670 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12671 PyObject *resultobj;
12672 wxImage *arg1 = (wxImage *) 0 ;
12673 PyObject *result;
12674 PyObject * obj0 = 0 ;
12675 char *kwnames[] = {
12676 (char *) "self", NULL
12677 };
12678
12679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12681 if (SWIG_arg_fail(1)) SWIG_fail;
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12685
12686 wxPyEndAllowThreads(__tstate);
12687 if (PyErr_Occurred()) SWIG_fail;
12688 }
12689 resultobj = result;
12690 return resultobj;
12691 fail:
12692 return NULL;
12693 }
12694
12695
12696 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12697 PyObject *resultobj;
12698 wxImage *arg1 = (wxImage *) 0 ;
12699 buffer arg2 ;
12700 int arg3 ;
12701 PyObject * obj0 = 0 ;
12702 PyObject * obj1 = 0 ;
12703 char *kwnames[] = {
12704 (char *) "self",(char *) "data", NULL
12705 };
12706
12707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12709 if (SWIG_arg_fail(1)) SWIG_fail;
12710 {
12711 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12712 }
12713 {
12714 PyThreadState* __tstate = wxPyBeginAllowThreads();
12715 wxImage_SetDataBuffer(arg1,arg2,arg3);
12716
12717 wxPyEndAllowThreads(__tstate);
12718 if (PyErr_Occurred()) SWIG_fail;
12719 }
12720 Py_INCREF(Py_None); resultobj = Py_None;
12721 return resultobj;
12722 fail:
12723 return NULL;
12724 }
12725
12726
12727 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12728 PyObject *resultobj;
12729 wxImage *arg1 = (wxImage *) 0 ;
12730 PyObject *result;
12731 PyObject * obj0 = 0 ;
12732 char *kwnames[] = {
12733 (char *) "self", NULL
12734 };
12735
12736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12738 if (SWIG_arg_fail(1)) SWIG_fail;
12739 {
12740 PyThreadState* __tstate = wxPyBeginAllowThreads();
12741 result = (PyObject *)wxImage_GetAlphaData(arg1);
12742
12743 wxPyEndAllowThreads(__tstate);
12744 if (PyErr_Occurred()) SWIG_fail;
12745 }
12746 resultobj = result;
12747 return resultobj;
12748 fail:
12749 return NULL;
12750 }
12751
12752
12753 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12754 PyObject *resultobj;
12755 wxImage *arg1 = (wxImage *) 0 ;
12756 buffer arg2 ;
12757 int arg3 ;
12758 PyObject * obj0 = 0 ;
12759 PyObject * obj1 = 0 ;
12760 char *kwnames[] = {
12761 (char *) "self",(char *) "alpha", NULL
12762 };
12763
12764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12766 if (SWIG_arg_fail(1)) SWIG_fail;
12767 {
12768 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12769 }
12770 {
12771 PyThreadState* __tstate = wxPyBeginAllowThreads();
12772 wxImage_SetAlphaData(arg1,arg2,arg3);
12773
12774 wxPyEndAllowThreads(__tstate);
12775 if (PyErr_Occurred()) SWIG_fail;
12776 }
12777 Py_INCREF(Py_None); resultobj = Py_None;
12778 return resultobj;
12779 fail:
12780 return NULL;
12781 }
12782
12783
12784 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12785 PyObject *resultobj;
12786 wxImage *arg1 = (wxImage *) 0 ;
12787 PyObject *result;
12788 PyObject * obj0 = 0 ;
12789 char *kwnames[] = {
12790 (char *) "self", NULL
12791 };
12792
12793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12795 if (SWIG_arg_fail(1)) SWIG_fail;
12796 {
12797 PyThreadState* __tstate = wxPyBeginAllowThreads();
12798 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12799
12800 wxPyEndAllowThreads(__tstate);
12801 if (PyErr_Occurred()) SWIG_fail;
12802 }
12803 resultobj = result;
12804 return resultobj;
12805 fail:
12806 return NULL;
12807 }
12808
12809
12810 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12811 PyObject *resultobj;
12812 wxImage *arg1 = (wxImage *) 0 ;
12813 buffer arg2 ;
12814 int arg3 ;
12815 PyObject * obj0 = 0 ;
12816 PyObject * obj1 = 0 ;
12817 char *kwnames[] = {
12818 (char *) "self",(char *) "alpha", NULL
12819 };
12820
12821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12823 if (SWIG_arg_fail(1)) SWIG_fail;
12824 {
12825 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12826 }
12827 {
12828 PyThreadState* __tstate = wxPyBeginAllowThreads();
12829 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12830
12831 wxPyEndAllowThreads(__tstate);
12832 if (PyErr_Occurred()) SWIG_fail;
12833 }
12834 Py_INCREF(Py_None); resultobj = Py_None;
12835 return resultobj;
12836 fail:
12837 return NULL;
12838 }
12839
12840
12841 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12842 PyObject *resultobj;
12843 wxImage *arg1 = (wxImage *) 0 ;
12844 byte arg2 ;
12845 byte arg3 ;
12846 byte arg4 ;
12847 PyObject * obj0 = 0 ;
12848 PyObject * obj1 = 0 ;
12849 PyObject * obj2 = 0 ;
12850 PyObject * obj3 = 0 ;
12851 char *kwnames[] = {
12852 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12853 };
12854
12855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12857 if (SWIG_arg_fail(1)) SWIG_fail;
12858 {
12859 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12860 if (SWIG_arg_fail(2)) SWIG_fail;
12861 }
12862 {
12863 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12864 if (SWIG_arg_fail(3)) SWIG_fail;
12865 }
12866 {
12867 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12868 if (SWIG_arg_fail(4)) SWIG_fail;
12869 }
12870 {
12871 PyThreadState* __tstate = wxPyBeginAllowThreads();
12872 (arg1)->SetMaskColour(arg2,arg3,arg4);
12873
12874 wxPyEndAllowThreads(__tstate);
12875 if (PyErr_Occurred()) SWIG_fail;
12876 }
12877 Py_INCREF(Py_None); resultobj = Py_None;
12878 return resultobj;
12879 fail:
12880 return NULL;
12881 }
12882
12883
12884 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12885 PyObject *resultobj;
12886 wxImage *arg1 = (wxImage *) 0 ;
12887 byte *arg2 = (byte *) 0 ;
12888 byte *arg3 = (byte *) 0 ;
12889 byte *arg4 = (byte *) 0 ;
12890 byte temp2 ;
12891 int res2 = 0 ;
12892 byte temp3 ;
12893 int res3 = 0 ;
12894 byte temp4 ;
12895 int res4 = 0 ;
12896 PyObject * obj0 = 0 ;
12897 char *kwnames[] = {
12898 (char *) "self", NULL
12899 };
12900
12901 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12902 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12903 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12906 if (SWIG_arg_fail(1)) SWIG_fail;
12907 {
12908 PyThreadState* __tstate = wxPyBeginAllowThreads();
12909 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12910
12911 wxPyEndAllowThreads(__tstate);
12912 if (PyErr_Occurred()) SWIG_fail;
12913 }
12914 Py_INCREF(Py_None); resultobj = Py_None;
12915 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12916 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12917 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12918 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12919 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12920 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12928 PyObject *resultobj;
12929 wxImage *arg1 = (wxImage *) 0 ;
12930 byte result;
12931 PyObject * obj0 = 0 ;
12932 char *kwnames[] = {
12933 (char *) "self", NULL
12934 };
12935
12936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12938 if (SWIG_arg_fail(1)) SWIG_fail;
12939 {
12940 PyThreadState* __tstate = wxPyBeginAllowThreads();
12941 result = (byte)(arg1)->GetMaskRed();
12942
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 {
12947 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12948 }
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12956 PyObject *resultobj;
12957 wxImage *arg1 = (wxImage *) 0 ;
12958 byte result;
12959 PyObject * obj0 = 0 ;
12960 char *kwnames[] = {
12961 (char *) "self", NULL
12962 };
12963
12964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12966 if (SWIG_arg_fail(1)) SWIG_fail;
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = (byte)(arg1)->GetMaskGreen();
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 {
12975 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12976 }
12977 return resultobj;
12978 fail:
12979 return NULL;
12980 }
12981
12982
12983 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12984 PyObject *resultobj;
12985 wxImage *arg1 = (wxImage *) 0 ;
12986 byte result;
12987 PyObject * obj0 = 0 ;
12988 char *kwnames[] = {
12989 (char *) "self", NULL
12990 };
12991
12992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12994 if (SWIG_arg_fail(1)) SWIG_fail;
12995 {
12996 PyThreadState* __tstate = wxPyBeginAllowThreads();
12997 result = (byte)(arg1)->GetMaskBlue();
12998
12999 wxPyEndAllowThreads(__tstate);
13000 if (PyErr_Occurred()) SWIG_fail;
13001 }
13002 {
13003 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13004 }
13005 return resultobj;
13006 fail:
13007 return NULL;
13008 }
13009
13010
13011 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13012 PyObject *resultobj;
13013 wxImage *arg1 = (wxImage *) 0 ;
13014 bool arg2 = (bool) true ;
13015 PyObject * obj0 = 0 ;
13016 PyObject * obj1 = 0 ;
13017 char *kwnames[] = {
13018 (char *) "self",(char *) "mask", NULL
13019 };
13020
13021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13023 if (SWIG_arg_fail(1)) SWIG_fail;
13024 if (obj1) {
13025 {
13026 arg2 = (bool)(SWIG_As_bool(obj1));
13027 if (SWIG_arg_fail(2)) SWIG_fail;
13028 }
13029 }
13030 {
13031 PyThreadState* __tstate = wxPyBeginAllowThreads();
13032 (arg1)->SetMask(arg2);
13033
13034 wxPyEndAllowThreads(__tstate);
13035 if (PyErr_Occurred()) SWIG_fail;
13036 }
13037 Py_INCREF(Py_None); resultobj = Py_None;
13038 return resultobj;
13039 fail:
13040 return NULL;
13041 }
13042
13043
13044 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13045 PyObject *resultobj;
13046 wxImage *arg1 = (wxImage *) 0 ;
13047 bool result;
13048 PyObject * obj0 = 0 ;
13049 char *kwnames[] = {
13050 (char *) "self", NULL
13051 };
13052
13053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13055 if (SWIG_arg_fail(1)) SWIG_fail;
13056 {
13057 PyThreadState* __tstate = wxPyBeginAllowThreads();
13058 result = (bool)(arg1)->HasMask();
13059
13060 wxPyEndAllowThreads(__tstate);
13061 if (PyErr_Occurred()) SWIG_fail;
13062 }
13063 {
13064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13065 }
13066 return resultobj;
13067 fail:
13068 return NULL;
13069 }
13070
13071
13072 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13073 PyObject *resultobj;
13074 wxImage *arg1 = (wxImage *) 0 ;
13075 double arg2 ;
13076 wxPoint *arg3 = 0 ;
13077 bool arg4 = (bool) true ;
13078 wxPoint *arg5 = (wxPoint *) NULL ;
13079 SwigValueWrapper<wxImage > result;
13080 wxPoint temp3 ;
13081 PyObject * obj0 = 0 ;
13082 PyObject * obj1 = 0 ;
13083 PyObject * obj2 = 0 ;
13084 PyObject * obj3 = 0 ;
13085 PyObject * obj4 = 0 ;
13086 char *kwnames[] = {
13087 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13088 };
13089
13090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13092 if (SWIG_arg_fail(1)) SWIG_fail;
13093 {
13094 arg2 = (double)(SWIG_As_double(obj1));
13095 if (SWIG_arg_fail(2)) SWIG_fail;
13096 }
13097 {
13098 arg3 = &temp3;
13099 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13100 }
13101 if (obj3) {
13102 {
13103 arg4 = (bool)(SWIG_As_bool(obj3));
13104 if (SWIG_arg_fail(4)) SWIG_fail;
13105 }
13106 }
13107 if (obj4) {
13108 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13109 if (SWIG_arg_fail(5)) SWIG_fail;
13110 }
13111 {
13112 PyThreadState* __tstate = wxPyBeginAllowThreads();
13113 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13114
13115 wxPyEndAllowThreads(__tstate);
13116 if (PyErr_Occurred()) SWIG_fail;
13117 }
13118 {
13119 wxImage * resultptr;
13120 resultptr = new wxImage((wxImage &)(result));
13121 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13122 }
13123 return resultobj;
13124 fail:
13125 return NULL;
13126 }
13127
13128
13129 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13130 PyObject *resultobj;
13131 wxImage *arg1 = (wxImage *) 0 ;
13132 bool arg2 = (bool) true ;
13133 SwigValueWrapper<wxImage > result;
13134 PyObject * obj0 = 0 ;
13135 PyObject * obj1 = 0 ;
13136 char *kwnames[] = {
13137 (char *) "self",(char *) "clockwise", NULL
13138 };
13139
13140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13142 if (SWIG_arg_fail(1)) SWIG_fail;
13143 if (obj1) {
13144 {
13145 arg2 = (bool)(SWIG_As_bool(obj1));
13146 if (SWIG_arg_fail(2)) SWIG_fail;
13147 }
13148 }
13149 {
13150 PyThreadState* __tstate = wxPyBeginAllowThreads();
13151 result = (arg1)->Rotate90(arg2);
13152
13153 wxPyEndAllowThreads(__tstate);
13154 if (PyErr_Occurred()) SWIG_fail;
13155 }
13156 {
13157 wxImage * resultptr;
13158 resultptr = new wxImage((wxImage &)(result));
13159 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13160 }
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj;
13169 wxImage *arg1 = (wxImage *) 0 ;
13170 bool arg2 = (bool) true ;
13171 SwigValueWrapper<wxImage > result;
13172 PyObject * obj0 = 0 ;
13173 PyObject * obj1 = 0 ;
13174 char *kwnames[] = {
13175 (char *) "self",(char *) "horizontally", NULL
13176 };
13177
13178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13180 if (SWIG_arg_fail(1)) SWIG_fail;
13181 if (obj1) {
13182 {
13183 arg2 = (bool)(SWIG_As_bool(obj1));
13184 if (SWIG_arg_fail(2)) SWIG_fail;
13185 }
13186 }
13187 {
13188 PyThreadState* __tstate = wxPyBeginAllowThreads();
13189 result = (arg1)->Mirror(arg2);
13190
13191 wxPyEndAllowThreads(__tstate);
13192 if (PyErr_Occurred()) SWIG_fail;
13193 }
13194 {
13195 wxImage * resultptr;
13196 resultptr = new wxImage((wxImage &)(result));
13197 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13198 }
13199 return resultobj;
13200 fail:
13201 return NULL;
13202 }
13203
13204
13205 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13206 PyObject *resultobj;
13207 wxImage *arg1 = (wxImage *) 0 ;
13208 byte arg2 ;
13209 byte arg3 ;
13210 byte arg4 ;
13211 byte arg5 ;
13212 byte arg6 ;
13213 byte arg7 ;
13214 PyObject * obj0 = 0 ;
13215 PyObject * obj1 = 0 ;
13216 PyObject * obj2 = 0 ;
13217 PyObject * obj3 = 0 ;
13218 PyObject * obj4 = 0 ;
13219 PyObject * obj5 = 0 ;
13220 PyObject * obj6 = 0 ;
13221 char *kwnames[] = {
13222 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13223 };
13224
13225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13227 if (SWIG_arg_fail(1)) SWIG_fail;
13228 {
13229 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13230 if (SWIG_arg_fail(2)) SWIG_fail;
13231 }
13232 {
13233 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13234 if (SWIG_arg_fail(3)) SWIG_fail;
13235 }
13236 {
13237 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13238 if (SWIG_arg_fail(4)) SWIG_fail;
13239 }
13240 {
13241 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
13242 if (SWIG_arg_fail(5)) SWIG_fail;
13243 }
13244 {
13245 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
13246 if (SWIG_arg_fail(6)) SWIG_fail;
13247 }
13248 {
13249 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj6));
13250 if (SWIG_arg_fail(7)) SWIG_fail;
13251 }
13252 {
13253 PyThreadState* __tstate = wxPyBeginAllowThreads();
13254 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13255
13256 wxPyEndAllowThreads(__tstate);
13257 if (PyErr_Occurred()) SWIG_fail;
13258 }
13259 Py_INCREF(Py_None); resultobj = Py_None;
13260 return resultobj;
13261 fail:
13262 return NULL;
13263 }
13264
13265
13266 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13267 PyObject *resultobj;
13268 wxImage *arg1 = (wxImage *) 0 ;
13269 byte arg2 ;
13270 byte arg3 ;
13271 byte arg4 ;
13272 SwigValueWrapper<wxImage > result;
13273 PyObject * obj0 = 0 ;
13274 PyObject * obj1 = 0 ;
13275 PyObject * obj2 = 0 ;
13276 PyObject * obj3 = 0 ;
13277 char *kwnames[] = {
13278 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13279 };
13280
13281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13283 if (SWIG_arg_fail(1)) SWIG_fail;
13284 {
13285 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13286 if (SWIG_arg_fail(2)) SWIG_fail;
13287 }
13288 {
13289 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13290 if (SWIG_arg_fail(3)) SWIG_fail;
13291 }
13292 {
13293 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13294 if (SWIG_arg_fail(4)) SWIG_fail;
13295 }
13296 {
13297 PyThreadState* __tstate = wxPyBeginAllowThreads();
13298 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13299
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 {
13304 wxImage * resultptr;
13305 resultptr = new wxImage((wxImage &)(result));
13306 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13307 }
13308 return resultobj;
13309 fail:
13310 return NULL;
13311 }
13312
13313
13314 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13315 PyObject *resultobj;
13316 wxImage *arg1 = (wxImage *) 0 ;
13317 wxString *arg2 = 0 ;
13318 wxString *arg3 = 0 ;
13319 bool temp2 = false ;
13320 bool temp3 = false ;
13321 PyObject * obj0 = 0 ;
13322 PyObject * obj1 = 0 ;
13323 PyObject * obj2 = 0 ;
13324 char *kwnames[] = {
13325 (char *) "self",(char *) "name",(char *) "value", NULL
13326 };
13327
13328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13330 if (SWIG_arg_fail(1)) SWIG_fail;
13331 {
13332 arg2 = wxString_in_helper(obj1);
13333 if (arg2 == NULL) SWIG_fail;
13334 temp2 = true;
13335 }
13336 {
13337 arg3 = wxString_in_helper(obj2);
13338 if (arg3 == NULL) SWIG_fail;
13339 temp3 = true;
13340 }
13341 {
13342 PyThreadState* __tstate = wxPyBeginAllowThreads();
13343 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13344
13345 wxPyEndAllowThreads(__tstate);
13346 if (PyErr_Occurred()) SWIG_fail;
13347 }
13348 Py_INCREF(Py_None); resultobj = Py_None;
13349 {
13350 if (temp2)
13351 delete arg2;
13352 }
13353 {
13354 if (temp3)
13355 delete arg3;
13356 }
13357 return resultobj;
13358 fail:
13359 {
13360 if (temp2)
13361 delete arg2;
13362 }
13363 {
13364 if (temp3)
13365 delete arg3;
13366 }
13367 return NULL;
13368 }
13369
13370
13371 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13372 PyObject *resultobj;
13373 wxImage *arg1 = (wxImage *) 0 ;
13374 wxString *arg2 = 0 ;
13375 int arg3 ;
13376 bool temp2 = false ;
13377 PyObject * obj0 = 0 ;
13378 PyObject * obj1 = 0 ;
13379 PyObject * obj2 = 0 ;
13380 char *kwnames[] = {
13381 (char *) "self",(char *) "name",(char *) "value", NULL
13382 };
13383
13384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13386 if (SWIG_arg_fail(1)) SWIG_fail;
13387 {
13388 arg2 = wxString_in_helper(obj1);
13389 if (arg2 == NULL) SWIG_fail;
13390 temp2 = true;
13391 }
13392 {
13393 arg3 = (int)(SWIG_As_int(obj2));
13394 if (SWIG_arg_fail(3)) SWIG_fail;
13395 }
13396 {
13397 PyThreadState* __tstate = wxPyBeginAllowThreads();
13398 (arg1)->SetOption((wxString const &)*arg2,arg3);
13399
13400 wxPyEndAllowThreads(__tstate);
13401 if (PyErr_Occurred()) SWIG_fail;
13402 }
13403 Py_INCREF(Py_None); resultobj = Py_None;
13404 {
13405 if (temp2)
13406 delete arg2;
13407 }
13408 return resultobj;
13409 fail:
13410 {
13411 if (temp2)
13412 delete arg2;
13413 }
13414 return NULL;
13415 }
13416
13417
13418 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13419 PyObject *resultobj;
13420 wxImage *arg1 = (wxImage *) 0 ;
13421 wxString *arg2 = 0 ;
13422 wxString result;
13423 bool temp2 = false ;
13424 PyObject * obj0 = 0 ;
13425 PyObject * obj1 = 0 ;
13426 char *kwnames[] = {
13427 (char *) "self",(char *) "name", NULL
13428 };
13429
13430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13432 if (SWIG_arg_fail(1)) SWIG_fail;
13433 {
13434 arg2 = wxString_in_helper(obj1);
13435 if (arg2 == NULL) SWIG_fail;
13436 temp2 = true;
13437 }
13438 {
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13441
13442 wxPyEndAllowThreads(__tstate);
13443 if (PyErr_Occurred()) SWIG_fail;
13444 }
13445 {
13446 #if wxUSE_UNICODE
13447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13448 #else
13449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13450 #endif
13451 }
13452 {
13453 if (temp2)
13454 delete arg2;
13455 }
13456 return resultobj;
13457 fail:
13458 {
13459 if (temp2)
13460 delete arg2;
13461 }
13462 return NULL;
13463 }
13464
13465
13466 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13467 PyObject *resultobj;
13468 wxImage *arg1 = (wxImage *) 0 ;
13469 wxString *arg2 = 0 ;
13470 int result;
13471 bool temp2 = false ;
13472 PyObject * obj0 = 0 ;
13473 PyObject * obj1 = 0 ;
13474 char *kwnames[] = {
13475 (char *) "self",(char *) "name", NULL
13476 };
13477
13478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13480 if (SWIG_arg_fail(1)) SWIG_fail;
13481 {
13482 arg2 = wxString_in_helper(obj1);
13483 if (arg2 == NULL) SWIG_fail;
13484 temp2 = true;
13485 }
13486 {
13487 PyThreadState* __tstate = wxPyBeginAllowThreads();
13488 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13489
13490 wxPyEndAllowThreads(__tstate);
13491 if (PyErr_Occurred()) SWIG_fail;
13492 }
13493 {
13494 resultobj = SWIG_From_int((int)(result));
13495 }
13496 {
13497 if (temp2)
13498 delete arg2;
13499 }
13500 return resultobj;
13501 fail:
13502 {
13503 if (temp2)
13504 delete arg2;
13505 }
13506 return NULL;
13507 }
13508
13509
13510 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj;
13512 wxImage *arg1 = (wxImage *) 0 ;
13513 wxString *arg2 = 0 ;
13514 bool result;
13515 bool temp2 = false ;
13516 PyObject * obj0 = 0 ;
13517 PyObject * obj1 = 0 ;
13518 char *kwnames[] = {
13519 (char *) "self",(char *) "name", NULL
13520 };
13521
13522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13524 if (SWIG_arg_fail(1)) SWIG_fail;
13525 {
13526 arg2 = wxString_in_helper(obj1);
13527 if (arg2 == NULL) SWIG_fail;
13528 temp2 = true;
13529 }
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13533
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 {
13538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13539 }
13540 {
13541 if (temp2)
13542 delete arg2;
13543 }
13544 return resultobj;
13545 fail:
13546 {
13547 if (temp2)
13548 delete arg2;
13549 }
13550 return NULL;
13551 }
13552
13553
13554 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13555 PyObject *resultobj;
13556 wxImage *arg1 = (wxImage *) 0 ;
13557 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13558 unsigned long result;
13559 PyObject * obj0 = 0 ;
13560 PyObject * obj1 = 0 ;
13561 char *kwnames[] = {
13562 (char *) "self",(char *) "stopafter", NULL
13563 };
13564
13565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13567 if (SWIG_arg_fail(1)) SWIG_fail;
13568 if (obj1) {
13569 {
13570 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13571 if (SWIG_arg_fail(2)) SWIG_fail;
13572 }
13573 }
13574 {
13575 PyThreadState* __tstate = wxPyBeginAllowThreads();
13576 result = (unsigned long)(arg1)->CountColours(arg2);
13577
13578 wxPyEndAllowThreads(__tstate);
13579 if (PyErr_Occurred()) SWIG_fail;
13580 }
13581 {
13582 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13583 }
13584 return resultobj;
13585 fail:
13586 return NULL;
13587 }
13588
13589
13590 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13591 PyObject *resultobj;
13592 wxImage *arg1 = (wxImage *) 0 ;
13593 wxImageHistogram *arg2 = 0 ;
13594 unsigned long result;
13595 PyObject * obj0 = 0 ;
13596 PyObject * obj1 = 0 ;
13597 char *kwnames[] = {
13598 (char *) "self",(char *) "h", NULL
13599 };
13600
13601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13603 if (SWIG_arg_fail(1)) SWIG_fail;
13604 {
13605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13606 if (SWIG_arg_fail(2)) SWIG_fail;
13607 if (arg2 == NULL) {
13608 SWIG_null_ref("wxImageHistogram");
13609 }
13610 if (SWIG_arg_fail(2)) SWIG_fail;
13611 }
13612 {
13613 PyThreadState* __tstate = wxPyBeginAllowThreads();
13614 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13615
13616 wxPyEndAllowThreads(__tstate);
13617 if (PyErr_Occurred()) SWIG_fail;
13618 }
13619 {
13620 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13621 }
13622 return resultobj;
13623 fail:
13624 return NULL;
13625 }
13626
13627
13628 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13629 PyObject *resultobj;
13630 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13631 PyObject * obj0 = 0 ;
13632 char *kwnames[] = {
13633 (char *) "handler", NULL
13634 };
13635
13636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13638 if (SWIG_arg_fail(1)) SWIG_fail;
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 wxImage::AddHandler(arg1);
13642
13643 wxPyEndAllowThreads(__tstate);
13644 if (PyErr_Occurred()) SWIG_fail;
13645 }
13646 Py_INCREF(Py_None); resultobj = Py_None;
13647 return resultobj;
13648 fail:
13649 return NULL;
13650 }
13651
13652
13653 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13654 PyObject *resultobj;
13655 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13656 PyObject * obj0 = 0 ;
13657 char *kwnames[] = {
13658 (char *) "handler", NULL
13659 };
13660
13661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13663 if (SWIG_arg_fail(1)) SWIG_fail;
13664 {
13665 PyThreadState* __tstate = wxPyBeginAllowThreads();
13666 wxImage::InsertHandler(arg1);
13667
13668 wxPyEndAllowThreads(__tstate);
13669 if (PyErr_Occurred()) SWIG_fail;
13670 }
13671 Py_INCREF(Py_None); resultobj = Py_None;
13672 return resultobj;
13673 fail:
13674 return NULL;
13675 }
13676
13677
13678 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13679 PyObject *resultobj;
13680 wxString *arg1 = 0 ;
13681 bool result;
13682 bool temp1 = false ;
13683 PyObject * obj0 = 0 ;
13684 char *kwnames[] = {
13685 (char *) "name", NULL
13686 };
13687
13688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13689 {
13690 arg1 = wxString_in_helper(obj0);
13691 if (arg1 == NULL) SWIG_fail;
13692 temp1 = true;
13693 }
13694 {
13695 PyThreadState* __tstate = wxPyBeginAllowThreads();
13696 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13697
13698 wxPyEndAllowThreads(__tstate);
13699 if (PyErr_Occurred()) SWIG_fail;
13700 }
13701 {
13702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13703 }
13704 {
13705 if (temp1)
13706 delete arg1;
13707 }
13708 return resultobj;
13709 fail:
13710 {
13711 if (temp1)
13712 delete arg1;
13713 }
13714 return NULL;
13715 }
13716
13717
13718 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13719 PyObject *resultobj;
13720 wxString result;
13721 char *kwnames[] = {
13722 NULL
13723 };
13724
13725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13726 {
13727 PyThreadState* __tstate = wxPyBeginAllowThreads();
13728 result = wxImage::GetImageExtWildcard();
13729
13730 wxPyEndAllowThreads(__tstate);
13731 if (PyErr_Occurred()) SWIG_fail;
13732 }
13733 {
13734 #if wxUSE_UNICODE
13735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13736 #else
13737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13738 #endif
13739 }
13740 return resultobj;
13741 fail:
13742 return NULL;
13743 }
13744
13745
13746 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13747 PyObject *resultobj;
13748 wxImage *arg1 = (wxImage *) 0 ;
13749 int arg2 = (int) -1 ;
13750 wxBitmap result;
13751 PyObject * obj0 = 0 ;
13752 PyObject * obj1 = 0 ;
13753 char *kwnames[] = {
13754 (char *) "self",(char *) "depth", NULL
13755 };
13756
13757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13759 if (SWIG_arg_fail(1)) SWIG_fail;
13760 if (obj1) {
13761 {
13762 arg2 = (int)(SWIG_As_int(obj1));
13763 if (SWIG_arg_fail(2)) SWIG_fail;
13764 }
13765 }
13766 {
13767 if (!wxPyCheckForApp()) SWIG_fail;
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 result = wxImage_ConvertToBitmap(arg1,arg2);
13770
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 {
13775 wxBitmap * resultptr;
13776 resultptr = new wxBitmap((wxBitmap &)(result));
13777 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13778 }
13779 return resultobj;
13780 fail:
13781 return NULL;
13782 }
13783
13784
13785 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13786 PyObject *resultobj;
13787 wxImage *arg1 = (wxImage *) 0 ;
13788 byte arg2 ;
13789 byte arg3 ;
13790 byte arg4 ;
13791 wxBitmap result;
13792 PyObject * obj0 = 0 ;
13793 PyObject * obj1 = 0 ;
13794 PyObject * obj2 = 0 ;
13795 PyObject * obj3 = 0 ;
13796 char *kwnames[] = {
13797 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13798 };
13799
13800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13802 if (SWIG_arg_fail(1)) SWIG_fail;
13803 {
13804 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13805 if (SWIG_arg_fail(2)) SWIG_fail;
13806 }
13807 {
13808 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13809 if (SWIG_arg_fail(3)) SWIG_fail;
13810 }
13811 {
13812 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13813 if (SWIG_arg_fail(4)) SWIG_fail;
13814 }
13815 {
13816 if (!wxPyCheckForApp()) SWIG_fail;
13817 PyThreadState* __tstate = wxPyBeginAllowThreads();
13818 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13819
13820 wxPyEndAllowThreads(__tstate);
13821 if (PyErr_Occurred()) SWIG_fail;
13822 }
13823 {
13824 wxBitmap * resultptr;
13825 resultptr = new wxBitmap((wxBitmap &)(result));
13826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13827 }
13828 return resultobj;
13829 fail:
13830 return NULL;
13831 }
13832
13833
13834 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13835 PyObject *obj;
13836 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13837 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13838 Py_INCREF(obj);
13839 return Py_BuildValue((char *)"");
13840 }
13841 static int _wrap_NullImage_set(PyObject *) {
13842 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13843 return 1;
13844 }
13845
13846
13847 static PyObject *_wrap_NullImage_get(void) {
13848 PyObject *pyobj;
13849
13850 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13851 return pyobj;
13852 }
13853
13854
13855 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13856 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13857 return 1;
13858 }
13859
13860
13861 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13862 PyObject *pyobj;
13863
13864 {
13865 #if wxUSE_UNICODE
13866 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13867 #else
13868 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13869 #endif
13870 }
13871 return pyobj;
13872 }
13873
13874
13875 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13876 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13877 return 1;
13878 }
13879
13880
13881 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13882 PyObject *pyobj;
13883
13884 {
13885 #if wxUSE_UNICODE
13886 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13887 #else
13888 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13889 #endif
13890 }
13891 return pyobj;
13892 }
13893
13894
13895 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13896 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13897 return 1;
13898 }
13899
13900
13901 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13902 PyObject *pyobj;
13903
13904 {
13905 #if wxUSE_UNICODE
13906 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13907 #else
13908 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13909 #endif
13910 }
13911 return pyobj;
13912 }
13913
13914
13915 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13916 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13917 return 1;
13918 }
13919
13920
13921 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13922 PyObject *pyobj;
13923
13924 {
13925 #if wxUSE_UNICODE
13926 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13927 #else
13928 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13929 #endif
13930 }
13931 return pyobj;
13932 }
13933
13934
13935 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13936 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13937 return 1;
13938 }
13939
13940
13941 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13942 PyObject *pyobj;
13943
13944 {
13945 #if wxUSE_UNICODE
13946 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13947 #else
13948 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13949 #endif
13950 }
13951 return pyobj;
13952 }
13953
13954
13955 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13956 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13957 return 1;
13958 }
13959
13960
13961 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13962 PyObject *pyobj;
13963
13964 {
13965 #if wxUSE_UNICODE
13966 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13967 #else
13968 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13969 #endif
13970 }
13971 return pyobj;
13972 }
13973
13974
13975 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13976 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13977 return 1;
13978 }
13979
13980
13981 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13982 PyObject *pyobj;
13983
13984 {
13985 #if wxUSE_UNICODE
13986 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13987 #else
13988 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13989 #endif
13990 }
13991 return pyobj;
13992 }
13993
13994
13995 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13996 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13997 return 1;
13998 }
13999
14000
14001 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14002 PyObject *pyobj;
14003
14004 {
14005 #if wxUSE_UNICODE
14006 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14007 #else
14008 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14009 #endif
14010 }
14011 return pyobj;
14012 }
14013
14014
14015 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14016 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14017 return 1;
14018 }
14019
14020
14021 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14022 PyObject *pyobj;
14023
14024 {
14025 #if wxUSE_UNICODE
14026 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14027 #else
14028 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14029 #endif
14030 }
14031 return pyobj;
14032 }
14033
14034
14035 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14036 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14037 return 1;
14038 }
14039
14040
14041 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14042 PyObject *pyobj;
14043
14044 {
14045 #if wxUSE_UNICODE
14046 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14047 #else
14048 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14049 #endif
14050 }
14051 return pyobj;
14052 }
14053
14054
14055 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14056 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14057 return 1;
14058 }
14059
14060
14061 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14062 PyObject *pyobj;
14063
14064 {
14065 #if wxUSE_UNICODE
14066 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14067 #else
14068 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14069 #endif
14070 }
14071 return pyobj;
14072 }
14073
14074
14075 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14076 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14077 return 1;
14078 }
14079
14080
14081 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14082 PyObject *pyobj;
14083
14084 {
14085 #if wxUSE_UNICODE
14086 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14087 #else
14088 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14089 #endif
14090 }
14091 return pyobj;
14092 }
14093
14094
14095 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14096 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14097 return 1;
14098 }
14099
14100
14101 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14102 PyObject *pyobj;
14103
14104 {
14105 #if wxUSE_UNICODE
14106 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14107 #else
14108 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14109 #endif
14110 }
14111 return pyobj;
14112 }
14113
14114
14115 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14116 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14117 return 1;
14118 }
14119
14120
14121 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14122 PyObject *pyobj;
14123
14124 {
14125 #if wxUSE_UNICODE
14126 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14127 #else
14128 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14129 #endif
14130 }
14131 return pyobj;
14132 }
14133
14134
14135 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14136 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14137 return 1;
14138 }
14139
14140
14141 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14142 PyObject *pyobj;
14143
14144 {
14145 #if wxUSE_UNICODE
14146 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14147 #else
14148 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14149 #endif
14150 }
14151 return pyobj;
14152 }
14153
14154
14155 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14156 PyObject *resultobj;
14157 wxBMPHandler *result;
14158 char *kwnames[] = {
14159 NULL
14160 };
14161
14162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14163 {
14164 PyThreadState* __tstate = wxPyBeginAllowThreads();
14165 result = (wxBMPHandler *)new wxBMPHandler();
14166
14167 wxPyEndAllowThreads(__tstate);
14168 if (PyErr_Occurred()) SWIG_fail;
14169 }
14170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14178 PyObject *obj;
14179 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14180 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14181 Py_INCREF(obj);
14182 return Py_BuildValue((char *)"");
14183 }
14184 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14185 PyObject *resultobj;
14186 wxICOHandler *result;
14187 char *kwnames[] = {
14188 NULL
14189 };
14190
14191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 result = (wxICOHandler *)new wxICOHandler();
14195
14196 wxPyEndAllowThreads(__tstate);
14197 if (PyErr_Occurred()) SWIG_fail;
14198 }
14199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14200 return resultobj;
14201 fail:
14202 return NULL;
14203 }
14204
14205
14206 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14207 PyObject *obj;
14208 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14209 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14210 Py_INCREF(obj);
14211 return Py_BuildValue((char *)"");
14212 }
14213 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14214 PyObject *resultobj;
14215 wxCURHandler *result;
14216 char *kwnames[] = {
14217 NULL
14218 };
14219
14220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14221 {
14222 PyThreadState* __tstate = wxPyBeginAllowThreads();
14223 result = (wxCURHandler *)new wxCURHandler();
14224
14225 wxPyEndAllowThreads(__tstate);
14226 if (PyErr_Occurred()) SWIG_fail;
14227 }
14228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14229 return resultobj;
14230 fail:
14231 return NULL;
14232 }
14233
14234
14235 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14236 PyObject *obj;
14237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14238 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14239 Py_INCREF(obj);
14240 return Py_BuildValue((char *)"");
14241 }
14242 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14243 PyObject *resultobj;
14244 wxANIHandler *result;
14245 char *kwnames[] = {
14246 NULL
14247 };
14248
14249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14250 {
14251 PyThreadState* __tstate = wxPyBeginAllowThreads();
14252 result = (wxANIHandler *)new wxANIHandler();
14253
14254 wxPyEndAllowThreads(__tstate);
14255 if (PyErr_Occurred()) SWIG_fail;
14256 }
14257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14258 return resultobj;
14259 fail:
14260 return NULL;
14261 }
14262
14263
14264 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14265 PyObject *obj;
14266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14267 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14268 Py_INCREF(obj);
14269 return Py_BuildValue((char *)"");
14270 }
14271 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14272 PyObject *resultobj;
14273 wxPNGHandler *result;
14274 char *kwnames[] = {
14275 NULL
14276 };
14277
14278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14279 {
14280 PyThreadState* __tstate = wxPyBeginAllowThreads();
14281 result = (wxPNGHandler *)new wxPNGHandler();
14282
14283 wxPyEndAllowThreads(__tstate);
14284 if (PyErr_Occurred()) SWIG_fail;
14285 }
14286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14287 return resultobj;
14288 fail:
14289 return NULL;
14290 }
14291
14292
14293 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14294 PyObject *obj;
14295 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14296 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14297 Py_INCREF(obj);
14298 return Py_BuildValue((char *)"");
14299 }
14300 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14301 PyObject *resultobj;
14302 wxGIFHandler *result;
14303 char *kwnames[] = {
14304 NULL
14305 };
14306
14307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14308 {
14309 PyThreadState* __tstate = wxPyBeginAllowThreads();
14310 result = (wxGIFHandler *)new wxGIFHandler();
14311
14312 wxPyEndAllowThreads(__tstate);
14313 if (PyErr_Occurred()) SWIG_fail;
14314 }
14315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14323 PyObject *obj;
14324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14325 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14326 Py_INCREF(obj);
14327 return Py_BuildValue((char *)"");
14328 }
14329 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14330 PyObject *resultobj;
14331 wxPCXHandler *result;
14332 char *kwnames[] = {
14333 NULL
14334 };
14335
14336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14337 {
14338 PyThreadState* __tstate = wxPyBeginAllowThreads();
14339 result = (wxPCXHandler *)new wxPCXHandler();
14340
14341 wxPyEndAllowThreads(__tstate);
14342 if (PyErr_Occurred()) SWIG_fail;
14343 }
14344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14345 return resultobj;
14346 fail:
14347 return NULL;
14348 }
14349
14350
14351 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14352 PyObject *obj;
14353 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14354 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14355 Py_INCREF(obj);
14356 return Py_BuildValue((char *)"");
14357 }
14358 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14359 PyObject *resultobj;
14360 wxJPEGHandler *result;
14361 char *kwnames[] = {
14362 NULL
14363 };
14364
14365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14366 {
14367 PyThreadState* __tstate = wxPyBeginAllowThreads();
14368 result = (wxJPEGHandler *)new wxJPEGHandler();
14369
14370 wxPyEndAllowThreads(__tstate);
14371 if (PyErr_Occurred()) SWIG_fail;
14372 }
14373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14374 return resultobj;
14375 fail:
14376 return NULL;
14377 }
14378
14379
14380 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14381 PyObject *obj;
14382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14383 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14384 Py_INCREF(obj);
14385 return Py_BuildValue((char *)"");
14386 }
14387 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14388 PyObject *resultobj;
14389 wxPNMHandler *result;
14390 char *kwnames[] = {
14391 NULL
14392 };
14393
14394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 result = (wxPNMHandler *)new wxPNMHandler();
14398
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14410 PyObject *obj;
14411 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14412 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14413 Py_INCREF(obj);
14414 return Py_BuildValue((char *)"");
14415 }
14416 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj;
14418 wxXPMHandler *result;
14419 char *kwnames[] = {
14420 NULL
14421 };
14422
14423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = (wxXPMHandler *)new wxXPMHandler();
14427
14428 wxPyEndAllowThreads(__tstate);
14429 if (PyErr_Occurred()) SWIG_fail;
14430 }
14431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14432 return resultobj;
14433 fail:
14434 return NULL;
14435 }
14436
14437
14438 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14439 PyObject *obj;
14440 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14441 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14442 Py_INCREF(obj);
14443 return Py_BuildValue((char *)"");
14444 }
14445 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14446 PyObject *resultobj;
14447 wxTIFFHandler *result;
14448 char *kwnames[] = {
14449 NULL
14450 };
14451
14452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14453 {
14454 PyThreadState* __tstate = wxPyBeginAllowThreads();
14455 result = (wxTIFFHandler *)new wxTIFFHandler();
14456
14457 wxPyEndAllowThreads(__tstate);
14458 if (PyErr_Occurred()) SWIG_fail;
14459 }
14460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14461 return resultobj;
14462 fail:
14463 return NULL;
14464 }
14465
14466
14467 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14468 PyObject *obj;
14469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14470 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14471 Py_INCREF(obj);
14472 return Py_BuildValue((char *)"");
14473 }
14474 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj;
14476 wxImage *arg1 = 0 ;
14477 wxImage *arg2 = 0 ;
14478 int arg3 = (int) 236 ;
14479 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14480 bool result;
14481 PyObject * obj0 = 0 ;
14482 PyObject * obj1 = 0 ;
14483 PyObject * obj2 = 0 ;
14484 PyObject * obj3 = 0 ;
14485 char *kwnames[] = {
14486 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14487 };
14488
14489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14490 {
14491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14492 if (SWIG_arg_fail(1)) SWIG_fail;
14493 if (arg1 == NULL) {
14494 SWIG_null_ref("wxImage");
14495 }
14496 if (SWIG_arg_fail(1)) SWIG_fail;
14497 }
14498 {
14499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14500 if (SWIG_arg_fail(2)) SWIG_fail;
14501 if (arg2 == NULL) {
14502 SWIG_null_ref("wxImage");
14503 }
14504 if (SWIG_arg_fail(2)) SWIG_fail;
14505 }
14506 if (obj2) {
14507 {
14508 arg3 = (int)(SWIG_As_int(obj2));
14509 if (SWIG_arg_fail(3)) SWIG_fail;
14510 }
14511 }
14512 if (obj3) {
14513 {
14514 arg4 = (int)(SWIG_As_int(obj3));
14515 if (SWIG_arg_fail(4)) SWIG_fail;
14516 }
14517 }
14518 {
14519 PyThreadState* __tstate = wxPyBeginAllowThreads();
14520 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14521
14522 wxPyEndAllowThreads(__tstate);
14523 if (PyErr_Occurred()) SWIG_fail;
14524 }
14525 {
14526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14527 }
14528 return resultobj;
14529 fail:
14530 return NULL;
14531 }
14532
14533
14534 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14535 PyObject *obj;
14536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14537 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14538 Py_INCREF(obj);
14539 return Py_BuildValue((char *)"");
14540 }
14541 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14542 PyObject *resultobj;
14543 wxEvtHandler *result;
14544 char *kwnames[] = {
14545 NULL
14546 };
14547
14548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14549 {
14550 PyThreadState* __tstate = wxPyBeginAllowThreads();
14551 result = (wxEvtHandler *)new wxEvtHandler();
14552
14553 wxPyEndAllowThreads(__tstate);
14554 if (PyErr_Occurred()) SWIG_fail;
14555 }
14556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14557 return resultobj;
14558 fail:
14559 return NULL;
14560 }
14561
14562
14563 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14564 PyObject *resultobj;
14565 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14566 wxEvtHandler *result;
14567 PyObject * obj0 = 0 ;
14568 char *kwnames[] = {
14569 (char *) "self", NULL
14570 };
14571
14572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14574 if (SWIG_arg_fail(1)) SWIG_fail;
14575 {
14576 PyThreadState* __tstate = wxPyBeginAllowThreads();
14577 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14578
14579 wxPyEndAllowThreads(__tstate);
14580 if (PyErr_Occurred()) SWIG_fail;
14581 }
14582 {
14583 resultobj = wxPyMake_wxObject(result, 0);
14584 }
14585 return resultobj;
14586 fail:
14587 return NULL;
14588 }
14589
14590
14591 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14592 PyObject *resultobj;
14593 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14594 wxEvtHandler *result;
14595 PyObject * obj0 = 0 ;
14596 char *kwnames[] = {
14597 (char *) "self", NULL
14598 };
14599
14600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14602 if (SWIG_arg_fail(1)) SWIG_fail;
14603 {
14604 PyThreadState* __tstate = wxPyBeginAllowThreads();
14605 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14606
14607 wxPyEndAllowThreads(__tstate);
14608 if (PyErr_Occurred()) SWIG_fail;
14609 }
14610 {
14611 resultobj = wxPyMake_wxObject(result, 0);
14612 }
14613 return resultobj;
14614 fail:
14615 return NULL;
14616 }
14617
14618
14619 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14620 PyObject *resultobj;
14621 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14622 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14623 PyObject * obj0 = 0 ;
14624 PyObject * obj1 = 0 ;
14625 char *kwnames[] = {
14626 (char *) "self",(char *) "handler", NULL
14627 };
14628
14629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14631 if (SWIG_arg_fail(1)) SWIG_fail;
14632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14633 if (SWIG_arg_fail(2)) SWIG_fail;
14634 {
14635 PyThreadState* __tstate = wxPyBeginAllowThreads();
14636 (arg1)->SetNextHandler(arg2);
14637
14638 wxPyEndAllowThreads(__tstate);
14639 if (PyErr_Occurred()) SWIG_fail;
14640 }
14641 Py_INCREF(Py_None); resultobj = Py_None;
14642 return resultobj;
14643 fail:
14644 return NULL;
14645 }
14646
14647
14648 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14649 PyObject *resultobj;
14650 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14651 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14652 PyObject * obj0 = 0 ;
14653 PyObject * obj1 = 0 ;
14654 char *kwnames[] = {
14655 (char *) "self",(char *) "handler", NULL
14656 };
14657
14658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14660 if (SWIG_arg_fail(1)) SWIG_fail;
14661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14662 if (SWIG_arg_fail(2)) SWIG_fail;
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 (arg1)->SetPreviousHandler(arg2);
14666
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 Py_INCREF(Py_None); resultobj = Py_None;
14671 return resultobj;
14672 fail:
14673 return NULL;
14674 }
14675
14676
14677 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14678 PyObject *resultobj;
14679 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14680 bool result;
14681 PyObject * obj0 = 0 ;
14682 char *kwnames[] = {
14683 (char *) "self", NULL
14684 };
14685
14686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14688 if (SWIG_arg_fail(1)) SWIG_fail;
14689 {
14690 PyThreadState* __tstate = wxPyBeginAllowThreads();
14691 result = (bool)(arg1)->GetEvtHandlerEnabled();
14692
14693 wxPyEndAllowThreads(__tstate);
14694 if (PyErr_Occurred()) SWIG_fail;
14695 }
14696 {
14697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14698 }
14699 return resultobj;
14700 fail:
14701 return NULL;
14702 }
14703
14704
14705 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14706 PyObject *resultobj;
14707 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14708 bool arg2 ;
14709 PyObject * obj0 = 0 ;
14710 PyObject * obj1 = 0 ;
14711 char *kwnames[] = {
14712 (char *) "self",(char *) "enabled", NULL
14713 };
14714
14715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14717 if (SWIG_arg_fail(1)) SWIG_fail;
14718 {
14719 arg2 = (bool)(SWIG_As_bool(obj1));
14720 if (SWIG_arg_fail(2)) SWIG_fail;
14721 }
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 (arg1)->SetEvtHandlerEnabled(arg2);
14725
14726 wxPyEndAllowThreads(__tstate);
14727 if (PyErr_Occurred()) SWIG_fail;
14728 }
14729 Py_INCREF(Py_None); resultobj = Py_None;
14730 return resultobj;
14731 fail:
14732 return NULL;
14733 }
14734
14735
14736 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14737 PyObject *resultobj;
14738 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14739 wxEvent *arg2 = 0 ;
14740 bool result;
14741 PyObject * obj0 = 0 ;
14742 PyObject * obj1 = 0 ;
14743 char *kwnames[] = {
14744 (char *) "self",(char *) "event", NULL
14745 };
14746
14747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14749 if (SWIG_arg_fail(1)) SWIG_fail;
14750 {
14751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14752 if (SWIG_arg_fail(2)) SWIG_fail;
14753 if (arg2 == NULL) {
14754 SWIG_null_ref("wxEvent");
14755 }
14756 if (SWIG_arg_fail(2)) SWIG_fail;
14757 }
14758 {
14759 PyThreadState* __tstate = wxPyBeginAllowThreads();
14760 result = (bool)(arg1)->ProcessEvent(*arg2);
14761
14762 wxPyEndAllowThreads(__tstate);
14763 if (PyErr_Occurred()) SWIG_fail;
14764 }
14765 {
14766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14767 }
14768 return resultobj;
14769 fail:
14770 return NULL;
14771 }
14772
14773
14774 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14775 PyObject *resultobj;
14776 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14777 wxEvent *arg2 = 0 ;
14778 PyObject * obj0 = 0 ;
14779 PyObject * obj1 = 0 ;
14780 char *kwnames[] = {
14781 (char *) "self",(char *) "event", NULL
14782 };
14783
14784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14786 if (SWIG_arg_fail(1)) SWIG_fail;
14787 {
14788 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14789 if (SWIG_arg_fail(2)) SWIG_fail;
14790 if (arg2 == NULL) {
14791 SWIG_null_ref("wxEvent");
14792 }
14793 if (SWIG_arg_fail(2)) SWIG_fail;
14794 }
14795 {
14796 PyThreadState* __tstate = wxPyBeginAllowThreads();
14797 (arg1)->AddPendingEvent(*arg2);
14798
14799 wxPyEndAllowThreads(__tstate);
14800 if (PyErr_Occurred()) SWIG_fail;
14801 }
14802 Py_INCREF(Py_None); resultobj = Py_None;
14803 return resultobj;
14804 fail:
14805 return NULL;
14806 }
14807
14808
14809 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14810 PyObject *resultobj;
14811 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14812 PyObject * obj0 = 0 ;
14813 char *kwnames[] = {
14814 (char *) "self", NULL
14815 };
14816
14817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14819 if (SWIG_arg_fail(1)) SWIG_fail;
14820 {
14821 PyThreadState* __tstate = wxPyBeginAllowThreads();
14822 (arg1)->ProcessPendingEvents();
14823
14824 wxPyEndAllowThreads(__tstate);
14825 if (PyErr_Occurred()) SWIG_fail;
14826 }
14827 Py_INCREF(Py_None); resultobj = Py_None;
14828 return resultobj;
14829 fail:
14830 return NULL;
14831 }
14832
14833
14834 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14835 PyObject *resultobj;
14836 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14837 int arg2 ;
14838 int arg3 ;
14839 int arg4 ;
14840 PyObject *arg5 = (PyObject *) 0 ;
14841 PyObject * obj0 = 0 ;
14842 PyObject * obj1 = 0 ;
14843 PyObject * obj2 = 0 ;
14844 PyObject * obj3 = 0 ;
14845 PyObject * obj4 = 0 ;
14846 char *kwnames[] = {
14847 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14848 };
14849
14850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14852 if (SWIG_arg_fail(1)) SWIG_fail;
14853 {
14854 arg2 = (int)(SWIG_As_int(obj1));
14855 if (SWIG_arg_fail(2)) SWIG_fail;
14856 }
14857 {
14858 arg3 = (int)(SWIG_As_int(obj2));
14859 if (SWIG_arg_fail(3)) SWIG_fail;
14860 }
14861 {
14862 arg4 = (int)(SWIG_As_int(obj3));
14863 if (SWIG_arg_fail(4)) SWIG_fail;
14864 }
14865 arg5 = obj4;
14866 {
14867 PyThreadState* __tstate = wxPyBeginAllowThreads();
14868 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14869
14870 wxPyEndAllowThreads(__tstate);
14871 if (PyErr_Occurred()) SWIG_fail;
14872 }
14873 Py_INCREF(Py_None); resultobj = Py_None;
14874 return resultobj;
14875 fail:
14876 return NULL;
14877 }
14878
14879
14880 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14881 PyObject *resultobj;
14882 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14883 int arg2 ;
14884 int arg3 = (int) -1 ;
14885 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14886 bool result;
14887 PyObject * obj0 = 0 ;
14888 PyObject * obj1 = 0 ;
14889 PyObject * obj2 = 0 ;
14890 PyObject * obj3 = 0 ;
14891 char *kwnames[] = {
14892 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14893 };
14894
14895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14897 if (SWIG_arg_fail(1)) SWIG_fail;
14898 {
14899 arg2 = (int)(SWIG_As_int(obj1));
14900 if (SWIG_arg_fail(2)) SWIG_fail;
14901 }
14902 if (obj2) {
14903 {
14904 arg3 = (int)(SWIG_As_int(obj2));
14905 if (SWIG_arg_fail(3)) SWIG_fail;
14906 }
14907 }
14908 if (obj3) {
14909 {
14910 arg4 = (wxEventType)(SWIG_As_int(obj3));
14911 if (SWIG_arg_fail(4)) SWIG_fail;
14912 }
14913 }
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14917
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 {
14922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14923 }
14924 return resultobj;
14925 fail:
14926 return NULL;
14927 }
14928
14929
14930 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14931 PyObject *resultobj;
14932 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14933 PyObject *arg2 = (PyObject *) 0 ;
14934 bool arg3 = (bool) true ;
14935 PyObject * obj0 = 0 ;
14936 PyObject * obj1 = 0 ;
14937 PyObject * obj2 = 0 ;
14938 char *kwnames[] = {
14939 (char *) "self",(char *) "_self",(char *) "incref", NULL
14940 };
14941
14942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14944 if (SWIG_arg_fail(1)) SWIG_fail;
14945 arg2 = obj1;
14946 if (obj2) {
14947 {
14948 arg3 = (bool)(SWIG_As_bool(obj2));
14949 if (SWIG_arg_fail(3)) SWIG_fail;
14950 }
14951 }
14952 {
14953 PyThreadState* __tstate = wxPyBeginAllowThreads();
14954 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14955
14956 wxPyEndAllowThreads(__tstate);
14957 if (PyErr_Occurred()) SWIG_fail;
14958 }
14959 Py_INCREF(Py_None); resultobj = Py_None;
14960 return resultobj;
14961 fail:
14962 return NULL;
14963 }
14964
14965
14966 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14967 PyObject *obj;
14968 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14969 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14970 Py_INCREF(obj);
14971 return Py_BuildValue((char *)"");
14972 }
14973 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14974 PyObject *resultobj;
14975 wxEventType result;
14976 char *kwnames[] = {
14977 NULL
14978 };
14979
14980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14981 {
14982 PyThreadState* __tstate = wxPyBeginAllowThreads();
14983 result = (wxEventType)wxNewEventType();
14984
14985 wxPyEndAllowThreads(__tstate);
14986 if (PyErr_Occurred()) SWIG_fail;
14987 }
14988 {
14989 resultobj = SWIG_From_int((int)(result));
14990 }
14991 return resultobj;
14992 fail:
14993 return NULL;
14994 }
14995
14996
14997 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14998 PyObject *resultobj;
14999 wxEvent *arg1 = (wxEvent *) 0 ;
15000 PyObject * obj0 = 0 ;
15001 char *kwnames[] = {
15002 (char *) "self", NULL
15003 };
15004
15005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15007 if (SWIG_arg_fail(1)) SWIG_fail;
15008 {
15009 PyThreadState* __tstate = wxPyBeginAllowThreads();
15010 delete arg1;
15011
15012 wxPyEndAllowThreads(__tstate);
15013 if (PyErr_Occurred()) SWIG_fail;
15014 }
15015 Py_INCREF(Py_None); resultobj = Py_None;
15016 return resultobj;
15017 fail:
15018 return NULL;
15019 }
15020
15021
15022 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15023 PyObject *resultobj;
15024 wxEvent *arg1 = (wxEvent *) 0 ;
15025 wxEventType arg2 ;
15026 PyObject * obj0 = 0 ;
15027 PyObject * obj1 = 0 ;
15028 char *kwnames[] = {
15029 (char *) "self",(char *) "typ", NULL
15030 };
15031
15032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15034 if (SWIG_arg_fail(1)) SWIG_fail;
15035 {
15036 arg2 = (wxEventType)(SWIG_As_int(obj1));
15037 if (SWIG_arg_fail(2)) SWIG_fail;
15038 }
15039 {
15040 PyThreadState* __tstate = wxPyBeginAllowThreads();
15041 (arg1)->SetEventType(arg2);
15042
15043 wxPyEndAllowThreads(__tstate);
15044 if (PyErr_Occurred()) SWIG_fail;
15045 }
15046 Py_INCREF(Py_None); resultobj = Py_None;
15047 return resultobj;
15048 fail:
15049 return NULL;
15050 }
15051
15052
15053 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15054 PyObject *resultobj;
15055 wxEvent *arg1 = (wxEvent *) 0 ;
15056 wxEventType result;
15057 PyObject * obj0 = 0 ;
15058 char *kwnames[] = {
15059 (char *) "self", NULL
15060 };
15061
15062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15064 if (SWIG_arg_fail(1)) SWIG_fail;
15065 {
15066 PyThreadState* __tstate = wxPyBeginAllowThreads();
15067 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15068
15069 wxPyEndAllowThreads(__tstate);
15070 if (PyErr_Occurred()) SWIG_fail;
15071 }
15072 {
15073 resultobj = SWIG_From_int((int)(result));
15074 }
15075 return resultobj;
15076 fail:
15077 return NULL;
15078 }
15079
15080
15081 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15082 PyObject *resultobj;
15083 wxEvent *arg1 = (wxEvent *) 0 ;
15084 wxObject *result;
15085 PyObject * obj0 = 0 ;
15086 char *kwnames[] = {
15087 (char *) "self", NULL
15088 };
15089
15090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15092 if (SWIG_arg_fail(1)) SWIG_fail;
15093 {
15094 PyThreadState* __tstate = wxPyBeginAllowThreads();
15095 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15096
15097 wxPyEndAllowThreads(__tstate);
15098 if (PyErr_Occurred()) SWIG_fail;
15099 }
15100 {
15101 resultobj = wxPyMake_wxObject(result, 0);
15102 }
15103 return resultobj;
15104 fail:
15105 return NULL;
15106 }
15107
15108
15109 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15110 PyObject *resultobj;
15111 wxEvent *arg1 = (wxEvent *) 0 ;
15112 wxObject *arg2 = (wxObject *) 0 ;
15113 PyObject * obj0 = 0 ;
15114 PyObject * obj1 = 0 ;
15115 char *kwnames[] = {
15116 (char *) "self",(char *) "obj", NULL
15117 };
15118
15119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15121 if (SWIG_arg_fail(1)) SWIG_fail;
15122 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15123 if (SWIG_arg_fail(2)) SWIG_fail;
15124 {
15125 PyThreadState* __tstate = wxPyBeginAllowThreads();
15126 (arg1)->SetEventObject(arg2);
15127
15128 wxPyEndAllowThreads(__tstate);
15129 if (PyErr_Occurred()) SWIG_fail;
15130 }
15131 Py_INCREF(Py_None); resultobj = Py_None;
15132 return resultobj;
15133 fail:
15134 return NULL;
15135 }
15136
15137
15138 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15139 PyObject *resultobj;
15140 wxEvent *arg1 = (wxEvent *) 0 ;
15141 long result;
15142 PyObject * obj0 = 0 ;
15143 char *kwnames[] = {
15144 (char *) "self", NULL
15145 };
15146
15147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15149 if (SWIG_arg_fail(1)) SWIG_fail;
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15153
15154 wxPyEndAllowThreads(__tstate);
15155 if (PyErr_Occurred()) SWIG_fail;
15156 }
15157 {
15158 resultobj = SWIG_From_long((long)(result));
15159 }
15160 return resultobj;
15161 fail:
15162 return NULL;
15163 }
15164
15165
15166 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15167 PyObject *resultobj;
15168 wxEvent *arg1 = (wxEvent *) 0 ;
15169 long arg2 = (long) 0 ;
15170 PyObject * obj0 = 0 ;
15171 PyObject * obj1 = 0 ;
15172 char *kwnames[] = {
15173 (char *) "self",(char *) "ts", NULL
15174 };
15175
15176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15178 if (SWIG_arg_fail(1)) SWIG_fail;
15179 if (obj1) {
15180 {
15181 arg2 = (long)(SWIG_As_long(obj1));
15182 if (SWIG_arg_fail(2)) SWIG_fail;
15183 }
15184 }
15185 {
15186 PyThreadState* __tstate = wxPyBeginAllowThreads();
15187 (arg1)->SetTimestamp(arg2);
15188
15189 wxPyEndAllowThreads(__tstate);
15190 if (PyErr_Occurred()) SWIG_fail;
15191 }
15192 Py_INCREF(Py_None); resultobj = Py_None;
15193 return resultobj;
15194 fail:
15195 return NULL;
15196 }
15197
15198
15199 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15200 PyObject *resultobj;
15201 wxEvent *arg1 = (wxEvent *) 0 ;
15202 int result;
15203 PyObject * obj0 = 0 ;
15204 char *kwnames[] = {
15205 (char *) "self", NULL
15206 };
15207
15208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15210 if (SWIG_arg_fail(1)) SWIG_fail;
15211 {
15212 PyThreadState* __tstate = wxPyBeginAllowThreads();
15213 result = (int)((wxEvent const *)arg1)->GetId();
15214
15215 wxPyEndAllowThreads(__tstate);
15216 if (PyErr_Occurred()) SWIG_fail;
15217 }
15218 {
15219 resultobj = SWIG_From_int((int)(result));
15220 }
15221 return resultobj;
15222 fail:
15223 return NULL;
15224 }
15225
15226
15227 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15228 PyObject *resultobj;
15229 wxEvent *arg1 = (wxEvent *) 0 ;
15230 int arg2 ;
15231 PyObject * obj0 = 0 ;
15232 PyObject * obj1 = 0 ;
15233 char *kwnames[] = {
15234 (char *) "self",(char *) "Id", NULL
15235 };
15236
15237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15239 if (SWIG_arg_fail(1)) SWIG_fail;
15240 {
15241 arg2 = (int)(SWIG_As_int(obj1));
15242 if (SWIG_arg_fail(2)) SWIG_fail;
15243 }
15244 {
15245 PyThreadState* __tstate = wxPyBeginAllowThreads();
15246 (arg1)->SetId(arg2);
15247
15248 wxPyEndAllowThreads(__tstate);
15249 if (PyErr_Occurred()) SWIG_fail;
15250 }
15251 Py_INCREF(Py_None); resultobj = Py_None;
15252 return resultobj;
15253 fail:
15254 return NULL;
15255 }
15256
15257
15258 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15259 PyObject *resultobj;
15260 wxEvent *arg1 = (wxEvent *) 0 ;
15261 bool result;
15262 PyObject * obj0 = 0 ;
15263 char *kwnames[] = {
15264 (char *) "self", NULL
15265 };
15266
15267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15269 if (SWIG_arg_fail(1)) SWIG_fail;
15270 {
15271 PyThreadState* __tstate = wxPyBeginAllowThreads();
15272 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15273
15274 wxPyEndAllowThreads(__tstate);
15275 if (PyErr_Occurred()) SWIG_fail;
15276 }
15277 {
15278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15279 }
15280 return resultobj;
15281 fail:
15282 return NULL;
15283 }
15284
15285
15286 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15287 PyObject *resultobj;
15288 wxEvent *arg1 = (wxEvent *) 0 ;
15289 bool arg2 = (bool) true ;
15290 PyObject * obj0 = 0 ;
15291 PyObject * obj1 = 0 ;
15292 char *kwnames[] = {
15293 (char *) "self",(char *) "skip", NULL
15294 };
15295
15296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15298 if (SWIG_arg_fail(1)) SWIG_fail;
15299 if (obj1) {
15300 {
15301 arg2 = (bool)(SWIG_As_bool(obj1));
15302 if (SWIG_arg_fail(2)) SWIG_fail;
15303 }
15304 }
15305 {
15306 PyThreadState* __tstate = wxPyBeginAllowThreads();
15307 (arg1)->Skip(arg2);
15308
15309 wxPyEndAllowThreads(__tstate);
15310 if (PyErr_Occurred()) SWIG_fail;
15311 }
15312 Py_INCREF(Py_None); resultobj = Py_None;
15313 return resultobj;
15314 fail:
15315 return NULL;
15316 }
15317
15318
15319 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15320 PyObject *resultobj;
15321 wxEvent *arg1 = (wxEvent *) 0 ;
15322 bool result;
15323 PyObject * obj0 = 0 ;
15324 char *kwnames[] = {
15325 (char *) "self", NULL
15326 };
15327
15328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15330 if (SWIG_arg_fail(1)) SWIG_fail;
15331 {
15332 PyThreadState* __tstate = wxPyBeginAllowThreads();
15333 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15334
15335 wxPyEndAllowThreads(__tstate);
15336 if (PyErr_Occurred()) SWIG_fail;
15337 }
15338 {
15339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15340 }
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15348 PyObject *resultobj;
15349 wxEvent *arg1 = (wxEvent *) 0 ;
15350 bool result;
15351 PyObject * obj0 = 0 ;
15352 char *kwnames[] = {
15353 (char *) "self", NULL
15354 };
15355
15356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15358 if (SWIG_arg_fail(1)) SWIG_fail;
15359 {
15360 PyThreadState* __tstate = wxPyBeginAllowThreads();
15361 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15362
15363 wxPyEndAllowThreads(__tstate);
15364 if (PyErr_Occurred()) SWIG_fail;
15365 }
15366 {
15367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15368 }
15369 return resultobj;
15370 fail:
15371 return NULL;
15372 }
15373
15374
15375 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15376 PyObject *resultobj;
15377 wxEvent *arg1 = (wxEvent *) 0 ;
15378 int result;
15379 PyObject * obj0 = 0 ;
15380 char *kwnames[] = {
15381 (char *) "self", NULL
15382 };
15383
15384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15386 if (SWIG_arg_fail(1)) SWIG_fail;
15387 {
15388 PyThreadState* __tstate = wxPyBeginAllowThreads();
15389 result = (int)(arg1)->StopPropagation();
15390
15391 wxPyEndAllowThreads(__tstate);
15392 if (PyErr_Occurred()) SWIG_fail;
15393 }
15394 {
15395 resultobj = SWIG_From_int((int)(result));
15396 }
15397 return resultobj;
15398 fail:
15399 return NULL;
15400 }
15401
15402
15403 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15404 PyObject *resultobj;
15405 wxEvent *arg1 = (wxEvent *) 0 ;
15406 int arg2 ;
15407 PyObject * obj0 = 0 ;
15408 PyObject * obj1 = 0 ;
15409 char *kwnames[] = {
15410 (char *) "self",(char *) "propagationLevel", NULL
15411 };
15412
15413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15415 if (SWIG_arg_fail(1)) SWIG_fail;
15416 {
15417 arg2 = (int)(SWIG_As_int(obj1));
15418 if (SWIG_arg_fail(2)) SWIG_fail;
15419 }
15420 {
15421 PyThreadState* __tstate = wxPyBeginAllowThreads();
15422 (arg1)->ResumePropagation(arg2);
15423
15424 wxPyEndAllowThreads(__tstate);
15425 if (PyErr_Occurred()) SWIG_fail;
15426 }
15427 Py_INCREF(Py_None); resultobj = Py_None;
15428 return resultobj;
15429 fail:
15430 return NULL;
15431 }
15432
15433
15434 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15435 PyObject *resultobj;
15436 wxEvent *arg1 = (wxEvent *) 0 ;
15437 wxEvent *result;
15438 PyObject * obj0 = 0 ;
15439 char *kwnames[] = {
15440 (char *) "self", NULL
15441 };
15442
15443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15445 if (SWIG_arg_fail(1)) SWIG_fail;
15446 {
15447 PyThreadState* __tstate = wxPyBeginAllowThreads();
15448 result = (wxEvent *)(arg1)->Clone();
15449
15450 wxPyEndAllowThreads(__tstate);
15451 if (PyErr_Occurred()) SWIG_fail;
15452 }
15453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15454 return resultobj;
15455 fail:
15456 return NULL;
15457 }
15458
15459
15460 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15461 PyObject *obj;
15462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15463 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15464 Py_INCREF(obj);
15465 return Py_BuildValue((char *)"");
15466 }
15467 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15468 PyObject *resultobj;
15469 wxEvent *arg1 = 0 ;
15470 wxPropagationDisabler *result;
15471 PyObject * obj0 = 0 ;
15472 char *kwnames[] = {
15473 (char *) "event", NULL
15474 };
15475
15476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15477 {
15478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15479 if (SWIG_arg_fail(1)) SWIG_fail;
15480 if (arg1 == NULL) {
15481 SWIG_null_ref("wxEvent");
15482 }
15483 if (SWIG_arg_fail(1)) SWIG_fail;
15484 }
15485 {
15486 PyThreadState* __tstate = wxPyBeginAllowThreads();
15487 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15488
15489 wxPyEndAllowThreads(__tstate);
15490 if (PyErr_Occurred()) SWIG_fail;
15491 }
15492 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15493 return resultobj;
15494 fail:
15495 return NULL;
15496 }
15497
15498
15499 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15500 PyObject *resultobj;
15501 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15502 PyObject * obj0 = 0 ;
15503 char *kwnames[] = {
15504 (char *) "self", NULL
15505 };
15506
15507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15509 if (SWIG_arg_fail(1)) SWIG_fail;
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 delete arg1;
15513
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 Py_INCREF(Py_None); resultobj = Py_None;
15518 return resultobj;
15519 fail:
15520 return NULL;
15521 }
15522
15523
15524 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15525 PyObject *obj;
15526 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15527 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15528 Py_INCREF(obj);
15529 return Py_BuildValue((char *)"");
15530 }
15531 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15532 PyObject *resultobj;
15533 wxEvent *arg1 = 0 ;
15534 wxPropagateOnce *result;
15535 PyObject * obj0 = 0 ;
15536 char *kwnames[] = {
15537 (char *) "event", NULL
15538 };
15539
15540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15541 {
15542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15543 if (SWIG_arg_fail(1)) SWIG_fail;
15544 if (arg1 == NULL) {
15545 SWIG_null_ref("wxEvent");
15546 }
15547 if (SWIG_arg_fail(1)) SWIG_fail;
15548 }
15549 {
15550 PyThreadState* __tstate = wxPyBeginAllowThreads();
15551 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15552
15553 wxPyEndAllowThreads(__tstate);
15554 if (PyErr_Occurred()) SWIG_fail;
15555 }
15556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15557 return resultobj;
15558 fail:
15559 return NULL;
15560 }
15561
15562
15563 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15564 PyObject *resultobj;
15565 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15566 PyObject * obj0 = 0 ;
15567 char *kwnames[] = {
15568 (char *) "self", NULL
15569 };
15570
15571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15573 if (SWIG_arg_fail(1)) SWIG_fail;
15574 {
15575 PyThreadState* __tstate = wxPyBeginAllowThreads();
15576 delete arg1;
15577
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 Py_INCREF(Py_None); resultobj = Py_None;
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15589 PyObject *obj;
15590 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15591 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15592 Py_INCREF(obj);
15593 return Py_BuildValue((char *)"");
15594 }
15595 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15596 PyObject *resultobj;
15597 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15598 int arg2 = (int) 0 ;
15599 wxCommandEvent *result;
15600 PyObject * obj0 = 0 ;
15601 PyObject * obj1 = 0 ;
15602 char *kwnames[] = {
15603 (char *) "commandType",(char *) "winid", NULL
15604 };
15605
15606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15607 if (obj0) {
15608 {
15609 arg1 = (wxEventType)(SWIG_As_int(obj0));
15610 if (SWIG_arg_fail(1)) SWIG_fail;
15611 }
15612 }
15613 if (obj1) {
15614 {
15615 arg2 = (int)(SWIG_As_int(obj1));
15616 if (SWIG_arg_fail(2)) SWIG_fail;
15617 }
15618 }
15619 {
15620 PyThreadState* __tstate = wxPyBeginAllowThreads();
15621 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15622
15623 wxPyEndAllowThreads(__tstate);
15624 if (PyErr_Occurred()) SWIG_fail;
15625 }
15626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15627 return resultobj;
15628 fail:
15629 return NULL;
15630 }
15631
15632
15633 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15634 PyObject *resultobj;
15635 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15636 int result;
15637 PyObject * obj0 = 0 ;
15638 char *kwnames[] = {
15639 (char *) "self", NULL
15640 };
15641
15642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15644 if (SWIG_arg_fail(1)) SWIG_fail;
15645 {
15646 PyThreadState* __tstate = wxPyBeginAllowThreads();
15647 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15648
15649 wxPyEndAllowThreads(__tstate);
15650 if (PyErr_Occurred()) SWIG_fail;
15651 }
15652 {
15653 resultobj = SWIG_From_int((int)(result));
15654 }
15655 return resultobj;
15656 fail:
15657 return NULL;
15658 }
15659
15660
15661 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15662 PyObject *resultobj;
15663 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15664 wxString *arg2 = 0 ;
15665 bool temp2 = false ;
15666 PyObject * obj0 = 0 ;
15667 PyObject * obj1 = 0 ;
15668 char *kwnames[] = {
15669 (char *) "self",(char *) "s", NULL
15670 };
15671
15672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15674 if (SWIG_arg_fail(1)) SWIG_fail;
15675 {
15676 arg2 = wxString_in_helper(obj1);
15677 if (arg2 == NULL) SWIG_fail;
15678 temp2 = true;
15679 }
15680 {
15681 PyThreadState* __tstate = wxPyBeginAllowThreads();
15682 (arg1)->SetString((wxString const &)*arg2);
15683
15684 wxPyEndAllowThreads(__tstate);
15685 if (PyErr_Occurred()) SWIG_fail;
15686 }
15687 Py_INCREF(Py_None); resultobj = Py_None;
15688 {
15689 if (temp2)
15690 delete arg2;
15691 }
15692 return resultobj;
15693 fail:
15694 {
15695 if (temp2)
15696 delete arg2;
15697 }
15698 return NULL;
15699 }
15700
15701
15702 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15703 PyObject *resultobj;
15704 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15705 wxString result;
15706 PyObject * obj0 = 0 ;
15707 char *kwnames[] = {
15708 (char *) "self", NULL
15709 };
15710
15711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15713 if (SWIG_arg_fail(1)) SWIG_fail;
15714 {
15715 PyThreadState* __tstate = wxPyBeginAllowThreads();
15716 result = ((wxCommandEvent const *)arg1)->GetString();
15717
15718 wxPyEndAllowThreads(__tstate);
15719 if (PyErr_Occurred()) SWIG_fail;
15720 }
15721 {
15722 #if wxUSE_UNICODE
15723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15724 #else
15725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15726 #endif
15727 }
15728 return resultobj;
15729 fail:
15730 return NULL;
15731 }
15732
15733
15734 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15735 PyObject *resultobj;
15736 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15737 bool result;
15738 PyObject * obj0 = 0 ;
15739 char *kwnames[] = {
15740 (char *) "self", NULL
15741 };
15742
15743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15745 if (SWIG_arg_fail(1)) SWIG_fail;
15746 {
15747 PyThreadState* __tstate = wxPyBeginAllowThreads();
15748 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15749
15750 wxPyEndAllowThreads(__tstate);
15751 if (PyErr_Occurred()) SWIG_fail;
15752 }
15753 {
15754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15755 }
15756 return resultobj;
15757 fail:
15758 return NULL;
15759 }
15760
15761
15762 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15763 PyObject *resultobj;
15764 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15765 bool result;
15766 PyObject * obj0 = 0 ;
15767 char *kwnames[] = {
15768 (char *) "self", NULL
15769 };
15770
15771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15773 if (SWIG_arg_fail(1)) SWIG_fail;
15774 {
15775 PyThreadState* __tstate = wxPyBeginAllowThreads();
15776 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15777
15778 wxPyEndAllowThreads(__tstate);
15779 if (PyErr_Occurred()) SWIG_fail;
15780 }
15781 {
15782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15783 }
15784 return resultobj;
15785 fail:
15786 return NULL;
15787 }
15788
15789
15790 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15791 PyObject *resultobj;
15792 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15793 long arg2 ;
15794 PyObject * obj0 = 0 ;
15795 PyObject * obj1 = 0 ;
15796 char *kwnames[] = {
15797 (char *) "self",(char *) "extraLong", NULL
15798 };
15799
15800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15802 if (SWIG_arg_fail(1)) SWIG_fail;
15803 {
15804 arg2 = (long)(SWIG_As_long(obj1));
15805 if (SWIG_arg_fail(2)) SWIG_fail;
15806 }
15807 {
15808 PyThreadState* __tstate = wxPyBeginAllowThreads();
15809 (arg1)->SetExtraLong(arg2);
15810
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 Py_INCREF(Py_None); resultobj = Py_None;
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15822 PyObject *resultobj;
15823 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15824 long result;
15825 PyObject * obj0 = 0 ;
15826 char *kwnames[] = {
15827 (char *) "self", NULL
15828 };
15829
15830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15832 if (SWIG_arg_fail(1)) SWIG_fail;
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15836
15837 wxPyEndAllowThreads(__tstate);
15838 if (PyErr_Occurred()) SWIG_fail;
15839 }
15840 {
15841 resultobj = SWIG_From_long((long)(result));
15842 }
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15850 PyObject *resultobj;
15851 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15852 int arg2 ;
15853 PyObject * obj0 = 0 ;
15854 PyObject * obj1 = 0 ;
15855 char *kwnames[] = {
15856 (char *) "self",(char *) "i", NULL
15857 };
15858
15859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15861 if (SWIG_arg_fail(1)) SWIG_fail;
15862 {
15863 arg2 = (int)(SWIG_As_int(obj1));
15864 if (SWIG_arg_fail(2)) SWIG_fail;
15865 }
15866 {
15867 PyThreadState* __tstate = wxPyBeginAllowThreads();
15868 (arg1)->SetInt(arg2);
15869
15870 wxPyEndAllowThreads(__tstate);
15871 if (PyErr_Occurred()) SWIG_fail;
15872 }
15873 Py_INCREF(Py_None); resultobj = Py_None;
15874 return resultobj;
15875 fail:
15876 return NULL;
15877 }
15878
15879
15880 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15881 PyObject *resultobj;
15882 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15883 long result;
15884 PyObject * obj0 = 0 ;
15885 char *kwnames[] = {
15886 (char *) "self", NULL
15887 };
15888
15889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15891 if (SWIG_arg_fail(1)) SWIG_fail;
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15895
15896 wxPyEndAllowThreads(__tstate);
15897 if (PyErr_Occurred()) SWIG_fail;
15898 }
15899 {
15900 resultobj = SWIG_From_long((long)(result));
15901 }
15902 return resultobj;
15903 fail:
15904 return NULL;
15905 }
15906
15907
15908 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15909 PyObject *resultobj;
15910 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15911 wxEvent *result;
15912 PyObject * obj0 = 0 ;
15913 char *kwnames[] = {
15914 (char *) "self", NULL
15915 };
15916
15917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15919 if (SWIG_arg_fail(1)) SWIG_fail;
15920 {
15921 PyThreadState* __tstate = wxPyBeginAllowThreads();
15922 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15923
15924 wxPyEndAllowThreads(__tstate);
15925 if (PyErr_Occurred()) SWIG_fail;
15926 }
15927 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15928 return resultobj;
15929 fail:
15930 return NULL;
15931 }
15932
15933
15934 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15935 PyObject *obj;
15936 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15937 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15938 Py_INCREF(obj);
15939 return Py_BuildValue((char *)"");
15940 }
15941 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15942 PyObject *resultobj;
15943 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15944 int arg2 = (int) 0 ;
15945 wxNotifyEvent *result;
15946 PyObject * obj0 = 0 ;
15947 PyObject * obj1 = 0 ;
15948 char *kwnames[] = {
15949 (char *) "commandType",(char *) "winid", NULL
15950 };
15951
15952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15953 if (obj0) {
15954 {
15955 arg1 = (wxEventType)(SWIG_As_int(obj0));
15956 if (SWIG_arg_fail(1)) SWIG_fail;
15957 }
15958 }
15959 if (obj1) {
15960 {
15961 arg2 = (int)(SWIG_As_int(obj1));
15962 if (SWIG_arg_fail(2)) SWIG_fail;
15963 }
15964 }
15965 {
15966 PyThreadState* __tstate = wxPyBeginAllowThreads();
15967 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15968
15969 wxPyEndAllowThreads(__tstate);
15970 if (PyErr_Occurred()) SWIG_fail;
15971 }
15972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15973 return resultobj;
15974 fail:
15975 return NULL;
15976 }
15977
15978
15979 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15980 PyObject *resultobj;
15981 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15982 PyObject * obj0 = 0 ;
15983 char *kwnames[] = {
15984 (char *) "self", NULL
15985 };
15986
15987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15989 if (SWIG_arg_fail(1)) SWIG_fail;
15990 {
15991 PyThreadState* __tstate = wxPyBeginAllowThreads();
15992 (arg1)->Veto();
15993
15994 wxPyEndAllowThreads(__tstate);
15995 if (PyErr_Occurred()) SWIG_fail;
15996 }
15997 Py_INCREF(Py_None); resultobj = Py_None;
15998 return resultobj;
15999 fail:
16000 return NULL;
16001 }
16002
16003
16004 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16005 PyObject *resultobj;
16006 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16007 PyObject * obj0 = 0 ;
16008 char *kwnames[] = {
16009 (char *) "self", NULL
16010 };
16011
16012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16014 if (SWIG_arg_fail(1)) SWIG_fail;
16015 {
16016 PyThreadState* __tstate = wxPyBeginAllowThreads();
16017 (arg1)->Allow();
16018
16019 wxPyEndAllowThreads(__tstate);
16020 if (PyErr_Occurred()) SWIG_fail;
16021 }
16022 Py_INCREF(Py_None); resultobj = Py_None;
16023 return resultobj;
16024 fail:
16025 return NULL;
16026 }
16027
16028
16029 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16030 PyObject *resultobj;
16031 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16032 bool result;
16033 PyObject * obj0 = 0 ;
16034 char *kwnames[] = {
16035 (char *) "self", NULL
16036 };
16037
16038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16040 if (SWIG_arg_fail(1)) SWIG_fail;
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 result = (bool)(arg1)->IsAllowed();
16044
16045 wxPyEndAllowThreads(__tstate);
16046 if (PyErr_Occurred()) SWIG_fail;
16047 }
16048 {
16049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16050 }
16051 return resultobj;
16052 fail:
16053 return NULL;
16054 }
16055
16056
16057 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16058 PyObject *obj;
16059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16060 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16061 Py_INCREF(obj);
16062 return Py_BuildValue((char *)"");
16063 }
16064 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16065 PyObject *resultobj;
16066 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16067 int arg2 = (int) 0 ;
16068 int arg3 = (int) 0 ;
16069 int arg4 = (int) 0 ;
16070 wxScrollEvent *result;
16071 PyObject * obj0 = 0 ;
16072 PyObject * obj1 = 0 ;
16073 PyObject * obj2 = 0 ;
16074 PyObject * obj3 = 0 ;
16075 char *kwnames[] = {
16076 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16077 };
16078
16079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16080 if (obj0) {
16081 {
16082 arg1 = (wxEventType)(SWIG_As_int(obj0));
16083 if (SWIG_arg_fail(1)) SWIG_fail;
16084 }
16085 }
16086 if (obj1) {
16087 {
16088 arg2 = (int)(SWIG_As_int(obj1));
16089 if (SWIG_arg_fail(2)) SWIG_fail;
16090 }
16091 }
16092 if (obj2) {
16093 {
16094 arg3 = (int)(SWIG_As_int(obj2));
16095 if (SWIG_arg_fail(3)) SWIG_fail;
16096 }
16097 }
16098 if (obj3) {
16099 {
16100 arg4 = (int)(SWIG_As_int(obj3));
16101 if (SWIG_arg_fail(4)) SWIG_fail;
16102 }
16103 }
16104 {
16105 PyThreadState* __tstate = wxPyBeginAllowThreads();
16106 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16107
16108 wxPyEndAllowThreads(__tstate);
16109 if (PyErr_Occurred()) SWIG_fail;
16110 }
16111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16112 return resultobj;
16113 fail:
16114 return NULL;
16115 }
16116
16117
16118 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16119 PyObject *resultobj;
16120 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16121 int result;
16122 PyObject * obj0 = 0 ;
16123 char *kwnames[] = {
16124 (char *) "self", NULL
16125 };
16126
16127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16129 if (SWIG_arg_fail(1)) SWIG_fail;
16130 {
16131 PyThreadState* __tstate = wxPyBeginAllowThreads();
16132 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16133
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 {
16138 resultobj = SWIG_From_int((int)(result));
16139 }
16140 return resultobj;
16141 fail:
16142 return NULL;
16143 }
16144
16145
16146 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16147 PyObject *resultobj;
16148 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16149 int result;
16150 PyObject * obj0 = 0 ;
16151 char *kwnames[] = {
16152 (char *) "self", NULL
16153 };
16154
16155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16157 if (SWIG_arg_fail(1)) SWIG_fail;
16158 {
16159 PyThreadState* __tstate = wxPyBeginAllowThreads();
16160 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16161
16162 wxPyEndAllowThreads(__tstate);
16163 if (PyErr_Occurred()) SWIG_fail;
16164 }
16165 {
16166 resultobj = SWIG_From_int((int)(result));
16167 }
16168 return resultobj;
16169 fail:
16170 return NULL;
16171 }
16172
16173
16174 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16175 PyObject *resultobj;
16176 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16177 int arg2 ;
16178 PyObject * obj0 = 0 ;
16179 PyObject * obj1 = 0 ;
16180 char *kwnames[] = {
16181 (char *) "self",(char *) "orient", NULL
16182 };
16183
16184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16186 if (SWIG_arg_fail(1)) SWIG_fail;
16187 {
16188 arg2 = (int)(SWIG_As_int(obj1));
16189 if (SWIG_arg_fail(2)) SWIG_fail;
16190 }
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 (arg1)->SetOrientation(arg2);
16194
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 Py_INCREF(Py_None); resultobj = Py_None;
16199 return resultobj;
16200 fail:
16201 return NULL;
16202 }
16203
16204
16205 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16206 PyObject *resultobj;
16207 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16208 int arg2 ;
16209 PyObject * obj0 = 0 ;
16210 PyObject * obj1 = 0 ;
16211 char *kwnames[] = {
16212 (char *) "self",(char *) "pos", NULL
16213 };
16214
16215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16217 if (SWIG_arg_fail(1)) SWIG_fail;
16218 {
16219 arg2 = (int)(SWIG_As_int(obj1));
16220 if (SWIG_arg_fail(2)) SWIG_fail;
16221 }
16222 {
16223 PyThreadState* __tstate = wxPyBeginAllowThreads();
16224 (arg1)->SetPosition(arg2);
16225
16226 wxPyEndAllowThreads(__tstate);
16227 if (PyErr_Occurred()) SWIG_fail;
16228 }
16229 Py_INCREF(Py_None); resultobj = Py_None;
16230 return resultobj;
16231 fail:
16232 return NULL;
16233 }
16234
16235
16236 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16237 PyObject *obj;
16238 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16239 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16240 Py_INCREF(obj);
16241 return Py_BuildValue((char *)"");
16242 }
16243 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16244 PyObject *resultobj;
16245 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16246 int arg2 = (int) 0 ;
16247 int arg3 = (int) 0 ;
16248 wxScrollWinEvent *result;
16249 PyObject * obj0 = 0 ;
16250 PyObject * obj1 = 0 ;
16251 PyObject * obj2 = 0 ;
16252 char *kwnames[] = {
16253 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16254 };
16255
16256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16257 if (obj0) {
16258 {
16259 arg1 = (wxEventType)(SWIG_As_int(obj0));
16260 if (SWIG_arg_fail(1)) SWIG_fail;
16261 }
16262 }
16263 if (obj1) {
16264 {
16265 arg2 = (int)(SWIG_As_int(obj1));
16266 if (SWIG_arg_fail(2)) SWIG_fail;
16267 }
16268 }
16269 if (obj2) {
16270 {
16271 arg3 = (int)(SWIG_As_int(obj2));
16272 if (SWIG_arg_fail(3)) SWIG_fail;
16273 }
16274 }
16275 {
16276 PyThreadState* __tstate = wxPyBeginAllowThreads();
16277 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16278
16279 wxPyEndAllowThreads(__tstate);
16280 if (PyErr_Occurred()) SWIG_fail;
16281 }
16282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16283 return resultobj;
16284 fail:
16285 return NULL;
16286 }
16287
16288
16289 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16290 PyObject *resultobj;
16291 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16292 int result;
16293 PyObject * obj0 = 0 ;
16294 char *kwnames[] = {
16295 (char *) "self", NULL
16296 };
16297
16298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16300 if (SWIG_arg_fail(1)) SWIG_fail;
16301 {
16302 PyThreadState* __tstate = wxPyBeginAllowThreads();
16303 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16304
16305 wxPyEndAllowThreads(__tstate);
16306 if (PyErr_Occurred()) SWIG_fail;
16307 }
16308 {
16309 resultobj = SWIG_From_int((int)(result));
16310 }
16311 return resultobj;
16312 fail:
16313 return NULL;
16314 }
16315
16316
16317 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj;
16319 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16320 int result;
16321 PyObject * obj0 = 0 ;
16322 char *kwnames[] = {
16323 (char *) "self", NULL
16324 };
16325
16326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16328 if (SWIG_arg_fail(1)) SWIG_fail;
16329 {
16330 PyThreadState* __tstate = wxPyBeginAllowThreads();
16331 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16332
16333 wxPyEndAllowThreads(__tstate);
16334 if (PyErr_Occurred()) SWIG_fail;
16335 }
16336 {
16337 resultobj = SWIG_From_int((int)(result));
16338 }
16339 return resultobj;
16340 fail:
16341 return NULL;
16342 }
16343
16344
16345 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16346 PyObject *resultobj;
16347 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16348 int arg2 ;
16349 PyObject * obj0 = 0 ;
16350 PyObject * obj1 = 0 ;
16351 char *kwnames[] = {
16352 (char *) "self",(char *) "orient", NULL
16353 };
16354
16355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16357 if (SWIG_arg_fail(1)) SWIG_fail;
16358 {
16359 arg2 = (int)(SWIG_As_int(obj1));
16360 if (SWIG_arg_fail(2)) SWIG_fail;
16361 }
16362 {
16363 PyThreadState* __tstate = wxPyBeginAllowThreads();
16364 (arg1)->SetOrientation(arg2);
16365
16366 wxPyEndAllowThreads(__tstate);
16367 if (PyErr_Occurred()) SWIG_fail;
16368 }
16369 Py_INCREF(Py_None); resultobj = Py_None;
16370 return resultobj;
16371 fail:
16372 return NULL;
16373 }
16374
16375
16376 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16377 PyObject *resultobj;
16378 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16379 int arg2 ;
16380 PyObject * obj0 = 0 ;
16381 PyObject * obj1 = 0 ;
16382 char *kwnames[] = {
16383 (char *) "self",(char *) "pos", NULL
16384 };
16385
16386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16388 if (SWIG_arg_fail(1)) SWIG_fail;
16389 {
16390 arg2 = (int)(SWIG_As_int(obj1));
16391 if (SWIG_arg_fail(2)) SWIG_fail;
16392 }
16393 {
16394 PyThreadState* __tstate = wxPyBeginAllowThreads();
16395 (arg1)->SetPosition(arg2);
16396
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 Py_INCREF(Py_None); resultobj = Py_None;
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16408 PyObject *obj;
16409 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16410 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16411 Py_INCREF(obj);
16412 return Py_BuildValue((char *)"");
16413 }
16414 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16415 PyObject *resultobj;
16416 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16417 wxMouseEvent *result;
16418 PyObject * obj0 = 0 ;
16419 char *kwnames[] = {
16420 (char *) "mouseType", NULL
16421 };
16422
16423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16424 if (obj0) {
16425 {
16426 arg1 = (wxEventType)(SWIG_As_int(obj0));
16427 if (SWIG_arg_fail(1)) SWIG_fail;
16428 }
16429 }
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16433
16434 wxPyEndAllowThreads(__tstate);
16435 if (PyErr_Occurred()) SWIG_fail;
16436 }
16437 {
16438 resultobj = wxPyMake_wxObject(result, 1);
16439 }
16440 return resultobj;
16441 fail:
16442 return NULL;
16443 }
16444
16445
16446 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16447 PyObject *resultobj;
16448 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16449 bool result;
16450 PyObject * obj0 = 0 ;
16451 char *kwnames[] = {
16452 (char *) "self", NULL
16453 };
16454
16455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16457 if (SWIG_arg_fail(1)) SWIG_fail;
16458 {
16459 PyThreadState* __tstate = wxPyBeginAllowThreads();
16460 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16461
16462 wxPyEndAllowThreads(__tstate);
16463 if (PyErr_Occurred()) SWIG_fail;
16464 }
16465 {
16466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16467 }
16468 return resultobj;
16469 fail:
16470 return NULL;
16471 }
16472
16473
16474 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16475 PyObject *resultobj;
16476 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16477 int arg2 = (int) wxMOUSE_BTN_ANY ;
16478 bool result;
16479 PyObject * obj0 = 0 ;
16480 PyObject * obj1 = 0 ;
16481 char *kwnames[] = {
16482 (char *) "self",(char *) "but", NULL
16483 };
16484
16485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16487 if (SWIG_arg_fail(1)) SWIG_fail;
16488 if (obj1) {
16489 {
16490 arg2 = (int)(SWIG_As_int(obj1));
16491 if (SWIG_arg_fail(2)) SWIG_fail;
16492 }
16493 }
16494 {
16495 PyThreadState* __tstate = wxPyBeginAllowThreads();
16496 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16497
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 {
16502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16503 }
16504 return resultobj;
16505 fail:
16506 return NULL;
16507 }
16508
16509
16510 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16511 PyObject *resultobj;
16512 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16513 int arg2 = (int) wxMOUSE_BTN_ANY ;
16514 bool result;
16515 PyObject * obj0 = 0 ;
16516 PyObject * obj1 = 0 ;
16517 char *kwnames[] = {
16518 (char *) "self",(char *) "but", NULL
16519 };
16520
16521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16523 if (SWIG_arg_fail(1)) SWIG_fail;
16524 if (obj1) {
16525 {
16526 arg2 = (int)(SWIG_As_int(obj1));
16527 if (SWIG_arg_fail(2)) SWIG_fail;
16528 }
16529 }
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16533
16534 wxPyEndAllowThreads(__tstate);
16535 if (PyErr_Occurred()) SWIG_fail;
16536 }
16537 {
16538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16539 }
16540 return resultobj;
16541 fail:
16542 return NULL;
16543 }
16544
16545
16546 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16547 PyObject *resultobj;
16548 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16549 int arg2 = (int) wxMOUSE_BTN_ANY ;
16550 bool result;
16551 PyObject * obj0 = 0 ;
16552 PyObject * obj1 = 0 ;
16553 char *kwnames[] = {
16554 (char *) "self",(char *) "but", NULL
16555 };
16556
16557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16559 if (SWIG_arg_fail(1)) SWIG_fail;
16560 if (obj1) {
16561 {
16562 arg2 = (int)(SWIG_As_int(obj1));
16563 if (SWIG_arg_fail(2)) SWIG_fail;
16564 }
16565 }
16566 {
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16569
16570 wxPyEndAllowThreads(__tstate);
16571 if (PyErr_Occurred()) SWIG_fail;
16572 }
16573 {
16574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16575 }
16576 return resultobj;
16577 fail:
16578 return NULL;
16579 }
16580
16581
16582 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16583 PyObject *resultobj;
16584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16585 int arg2 ;
16586 bool result;
16587 PyObject * obj0 = 0 ;
16588 PyObject * obj1 = 0 ;
16589 char *kwnames[] = {
16590 (char *) "self",(char *) "button", NULL
16591 };
16592
16593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16595 if (SWIG_arg_fail(1)) SWIG_fail;
16596 {
16597 arg2 = (int)(SWIG_As_int(obj1));
16598 if (SWIG_arg_fail(2)) SWIG_fail;
16599 }
16600 {
16601 PyThreadState* __tstate = wxPyBeginAllowThreads();
16602 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16603
16604 wxPyEndAllowThreads(__tstate);
16605 if (PyErr_Occurred()) SWIG_fail;
16606 }
16607 {
16608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16609 }
16610 return resultobj;
16611 fail:
16612 return NULL;
16613 }
16614
16615
16616 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16617 PyObject *resultobj;
16618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16619 int arg2 ;
16620 bool result;
16621 PyObject * obj0 = 0 ;
16622 PyObject * obj1 = 0 ;
16623 char *kwnames[] = {
16624 (char *) "self",(char *) "but", NULL
16625 };
16626
16627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16629 if (SWIG_arg_fail(1)) SWIG_fail;
16630 {
16631 arg2 = (int)(SWIG_As_int(obj1));
16632 if (SWIG_arg_fail(2)) SWIG_fail;
16633 }
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16637
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 {
16642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16643 }
16644 return resultobj;
16645 fail:
16646 return NULL;
16647 }
16648
16649
16650 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16651 PyObject *resultobj;
16652 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16653 int result;
16654 PyObject * obj0 = 0 ;
16655 char *kwnames[] = {
16656 (char *) "self", NULL
16657 };
16658
16659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16661 if (SWIG_arg_fail(1)) SWIG_fail;
16662 {
16663 PyThreadState* __tstate = wxPyBeginAllowThreads();
16664 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16665
16666 wxPyEndAllowThreads(__tstate);
16667 if (PyErr_Occurred()) SWIG_fail;
16668 }
16669 {
16670 resultobj = SWIG_From_int((int)(result));
16671 }
16672 return resultobj;
16673 fail:
16674 return NULL;
16675 }
16676
16677
16678 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16679 PyObject *resultobj;
16680 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16681 bool result;
16682 PyObject * obj0 = 0 ;
16683 char *kwnames[] = {
16684 (char *) "self", NULL
16685 };
16686
16687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16689 if (SWIG_arg_fail(1)) SWIG_fail;
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16693
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 {
16698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16699 }
16700 return resultobj;
16701 fail:
16702 return NULL;
16703 }
16704
16705
16706 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16707 PyObject *resultobj;
16708 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16709 bool result;
16710 PyObject * obj0 = 0 ;
16711 char *kwnames[] = {
16712 (char *) "self", NULL
16713 };
16714
16715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16717 if (SWIG_arg_fail(1)) SWIG_fail;
16718 {
16719 PyThreadState* __tstate = wxPyBeginAllowThreads();
16720 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16721
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 {
16726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16727 }
16728 return resultobj;
16729 fail:
16730 return NULL;
16731 }
16732
16733
16734 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16735 PyObject *resultobj;
16736 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16737 bool result;
16738 PyObject * obj0 = 0 ;
16739 char *kwnames[] = {
16740 (char *) "self", NULL
16741 };
16742
16743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16745 if (SWIG_arg_fail(1)) SWIG_fail;
16746 {
16747 PyThreadState* __tstate = wxPyBeginAllowThreads();
16748 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16749
16750 wxPyEndAllowThreads(__tstate);
16751 if (PyErr_Occurred()) SWIG_fail;
16752 }
16753 {
16754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16755 }
16756 return resultobj;
16757 fail:
16758 return NULL;
16759 }
16760
16761
16762 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16763 PyObject *resultobj;
16764 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16765 bool result;
16766 PyObject * obj0 = 0 ;
16767 char *kwnames[] = {
16768 (char *) "self", NULL
16769 };
16770
16771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16773 if (SWIG_arg_fail(1)) SWIG_fail;
16774 {
16775 PyThreadState* __tstate = wxPyBeginAllowThreads();
16776 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16777
16778 wxPyEndAllowThreads(__tstate);
16779 if (PyErr_Occurred()) SWIG_fail;
16780 }
16781 {
16782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16783 }
16784 return resultobj;
16785 fail:
16786 return NULL;
16787 }
16788
16789
16790 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16791 PyObject *resultobj;
16792 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16793 bool result;
16794 PyObject * obj0 = 0 ;
16795 char *kwnames[] = {
16796 (char *) "self", NULL
16797 };
16798
16799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16801 if (SWIG_arg_fail(1)) SWIG_fail;
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16805
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 {
16810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16811 }
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj;
16820 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16821 bool result;
16822 PyObject * obj0 = 0 ;
16823 char *kwnames[] = {
16824 (char *) "self", NULL
16825 };
16826
16827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16829 if (SWIG_arg_fail(1)) SWIG_fail;
16830 {
16831 PyThreadState* __tstate = wxPyBeginAllowThreads();
16832 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16833
16834 wxPyEndAllowThreads(__tstate);
16835 if (PyErr_Occurred()) SWIG_fail;
16836 }
16837 {
16838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16839 }
16840 return resultobj;
16841 fail:
16842 return NULL;
16843 }
16844
16845
16846 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16847 PyObject *resultobj;
16848 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16849 bool result;
16850 PyObject * obj0 = 0 ;
16851 char *kwnames[] = {
16852 (char *) "self", NULL
16853 };
16854
16855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16857 if (SWIG_arg_fail(1)) SWIG_fail;
16858 {
16859 PyThreadState* __tstate = wxPyBeginAllowThreads();
16860 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16861
16862 wxPyEndAllowThreads(__tstate);
16863 if (PyErr_Occurred()) SWIG_fail;
16864 }
16865 {
16866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16867 }
16868 return resultobj;
16869 fail:
16870 return NULL;
16871 }
16872
16873
16874 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16875 PyObject *resultobj;
16876 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16877 bool result;
16878 PyObject * obj0 = 0 ;
16879 char *kwnames[] = {
16880 (char *) "self", NULL
16881 };
16882
16883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16885 if (SWIG_arg_fail(1)) SWIG_fail;
16886 {
16887 PyThreadState* __tstate = wxPyBeginAllowThreads();
16888 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16889
16890 wxPyEndAllowThreads(__tstate);
16891 if (PyErr_Occurred()) SWIG_fail;
16892 }
16893 {
16894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16895 }
16896 return resultobj;
16897 fail:
16898 return NULL;
16899 }
16900
16901
16902 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16903 PyObject *resultobj;
16904 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16905 bool result;
16906 PyObject * obj0 = 0 ;
16907 char *kwnames[] = {
16908 (char *) "self", NULL
16909 };
16910
16911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16913 if (SWIG_arg_fail(1)) SWIG_fail;
16914 {
16915 PyThreadState* __tstate = wxPyBeginAllowThreads();
16916 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16917
16918 wxPyEndAllowThreads(__tstate);
16919 if (PyErr_Occurred()) SWIG_fail;
16920 }
16921 {
16922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16923 }
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16931 PyObject *resultobj;
16932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16933 bool result;
16934 PyObject * obj0 = 0 ;
16935 char *kwnames[] = {
16936 (char *) "self", NULL
16937 };
16938
16939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16941 if (SWIG_arg_fail(1)) SWIG_fail;
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16945
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 {
16950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16951 }
16952 return resultobj;
16953 fail:
16954 return NULL;
16955 }
16956
16957
16958 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16959 PyObject *resultobj;
16960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16961 bool result;
16962 PyObject * obj0 = 0 ;
16963 char *kwnames[] = {
16964 (char *) "self", NULL
16965 };
16966
16967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16969 if (SWIG_arg_fail(1)) SWIG_fail;
16970 {
16971 PyThreadState* __tstate = wxPyBeginAllowThreads();
16972 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16973
16974 wxPyEndAllowThreads(__tstate);
16975 if (PyErr_Occurred()) SWIG_fail;
16976 }
16977 {
16978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16979 }
16980 return resultobj;
16981 fail:
16982 return NULL;
16983 }
16984
16985
16986 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16987 PyObject *resultobj;
16988 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16989 bool result;
16990 PyObject * obj0 = 0 ;
16991 char *kwnames[] = {
16992 (char *) "self", NULL
16993 };
16994
16995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16997 if (SWIG_arg_fail(1)) SWIG_fail;
16998 {
16999 PyThreadState* __tstate = wxPyBeginAllowThreads();
17000 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17001
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 {
17006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17007 }
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj;
17016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17017 bool result;
17018 PyObject * obj0 = 0 ;
17019 char *kwnames[] = {
17020 (char *) "self", NULL
17021 };
17022
17023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17025 if (SWIG_arg_fail(1)) SWIG_fail;
17026 {
17027 PyThreadState* __tstate = wxPyBeginAllowThreads();
17028 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17029
17030 wxPyEndAllowThreads(__tstate);
17031 if (PyErr_Occurred()) SWIG_fail;
17032 }
17033 {
17034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17035 }
17036 return resultobj;
17037 fail:
17038 return NULL;
17039 }
17040
17041
17042 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj;
17044 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17045 bool result;
17046 PyObject * obj0 = 0 ;
17047 char *kwnames[] = {
17048 (char *) "self", NULL
17049 };
17050
17051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17053 if (SWIG_arg_fail(1)) SWIG_fail;
17054 {
17055 PyThreadState* __tstate = wxPyBeginAllowThreads();
17056 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17057
17058 wxPyEndAllowThreads(__tstate);
17059 if (PyErr_Occurred()) SWIG_fail;
17060 }
17061 {
17062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17063 }
17064 return resultobj;
17065 fail:
17066 return NULL;
17067 }
17068
17069
17070 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17071 PyObject *resultobj;
17072 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17073 bool result;
17074 PyObject * obj0 = 0 ;
17075 char *kwnames[] = {
17076 (char *) "self", NULL
17077 };
17078
17079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17081 if (SWIG_arg_fail(1)) SWIG_fail;
17082 {
17083 PyThreadState* __tstate = wxPyBeginAllowThreads();
17084 result = (bool)(arg1)->LeftIsDown();
17085
17086 wxPyEndAllowThreads(__tstate);
17087 if (PyErr_Occurred()) SWIG_fail;
17088 }
17089 {
17090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17091 }
17092 return resultobj;
17093 fail:
17094 return NULL;
17095 }
17096
17097
17098 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17099 PyObject *resultobj;
17100 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17101 bool result;
17102 PyObject * obj0 = 0 ;
17103 char *kwnames[] = {
17104 (char *) "self", NULL
17105 };
17106
17107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17109 if (SWIG_arg_fail(1)) SWIG_fail;
17110 {
17111 PyThreadState* __tstate = wxPyBeginAllowThreads();
17112 result = (bool)(arg1)->MiddleIsDown();
17113
17114 wxPyEndAllowThreads(__tstate);
17115 if (PyErr_Occurred()) SWIG_fail;
17116 }
17117 {
17118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17119 }
17120 return resultobj;
17121 fail:
17122 return NULL;
17123 }
17124
17125
17126 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17127 PyObject *resultobj;
17128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17129 bool result;
17130 PyObject * obj0 = 0 ;
17131 char *kwnames[] = {
17132 (char *) "self", NULL
17133 };
17134
17135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17137 if (SWIG_arg_fail(1)) SWIG_fail;
17138 {
17139 PyThreadState* __tstate = wxPyBeginAllowThreads();
17140 result = (bool)(arg1)->RightIsDown();
17141
17142 wxPyEndAllowThreads(__tstate);
17143 if (PyErr_Occurred()) SWIG_fail;
17144 }
17145 {
17146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17147 }
17148 return resultobj;
17149 fail:
17150 return NULL;
17151 }
17152
17153
17154 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17155 PyObject *resultobj;
17156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17157 bool result;
17158 PyObject * obj0 = 0 ;
17159 char *kwnames[] = {
17160 (char *) "self", NULL
17161 };
17162
17163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17165 if (SWIG_arg_fail(1)) SWIG_fail;
17166 {
17167 PyThreadState* __tstate = wxPyBeginAllowThreads();
17168 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17169
17170 wxPyEndAllowThreads(__tstate);
17171 if (PyErr_Occurred()) SWIG_fail;
17172 }
17173 {
17174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17175 }
17176 return resultobj;
17177 fail:
17178 return NULL;
17179 }
17180
17181
17182 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17183 PyObject *resultobj;
17184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17185 bool result;
17186 PyObject * obj0 = 0 ;
17187 char *kwnames[] = {
17188 (char *) "self", NULL
17189 };
17190
17191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17193 if (SWIG_arg_fail(1)) SWIG_fail;
17194 {
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17197
17198 wxPyEndAllowThreads(__tstate);
17199 if (PyErr_Occurred()) SWIG_fail;
17200 }
17201 {
17202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17203 }
17204 return resultobj;
17205 fail:
17206 return NULL;
17207 }
17208
17209
17210 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj;
17212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17213 bool result;
17214 PyObject * obj0 = 0 ;
17215 char *kwnames[] = {
17216 (char *) "self", NULL
17217 };
17218
17219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17221 if (SWIG_arg_fail(1)) SWIG_fail;
17222 {
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17225
17226 wxPyEndAllowThreads(__tstate);
17227 if (PyErr_Occurred()) SWIG_fail;
17228 }
17229 {
17230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17231 }
17232 return resultobj;
17233 fail:
17234 return NULL;
17235 }
17236
17237
17238 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17239 PyObject *resultobj;
17240 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17241 bool result;
17242 PyObject * obj0 = 0 ;
17243 char *kwnames[] = {
17244 (char *) "self", NULL
17245 };
17246
17247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17253
17254 wxPyEndAllowThreads(__tstate);
17255 if (PyErr_Occurred()) SWIG_fail;
17256 }
17257 {
17258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17259 }
17260 return resultobj;
17261 fail:
17262 return NULL;
17263 }
17264
17265
17266 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17267 PyObject *resultobj;
17268 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17269 wxPoint result;
17270 PyObject * obj0 = 0 ;
17271 char *kwnames[] = {
17272 (char *) "self", NULL
17273 };
17274
17275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17277 if (SWIG_arg_fail(1)) SWIG_fail;
17278 {
17279 PyThreadState* __tstate = wxPyBeginAllowThreads();
17280 result = (arg1)->GetPosition();
17281
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 {
17286 wxPoint * resultptr;
17287 resultptr = new wxPoint((wxPoint &)(result));
17288 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17289 }
17290 return resultobj;
17291 fail:
17292 return NULL;
17293 }
17294
17295
17296 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17297 PyObject *resultobj;
17298 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17299 long *arg2 = (long *) 0 ;
17300 long *arg3 = (long *) 0 ;
17301 long temp2 ;
17302 int res2 = 0 ;
17303 long temp3 ;
17304 int res3 = 0 ;
17305 PyObject * obj0 = 0 ;
17306 char *kwnames[] = {
17307 (char *) "self", NULL
17308 };
17309
17310 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17311 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17314 if (SWIG_arg_fail(1)) SWIG_fail;
17315 {
17316 PyThreadState* __tstate = wxPyBeginAllowThreads();
17317 (arg1)->GetPosition(arg2,arg3);
17318
17319 wxPyEndAllowThreads(__tstate);
17320 if (PyErr_Occurred()) SWIG_fail;
17321 }
17322 Py_INCREF(Py_None); resultobj = Py_None;
17323 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17324 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17325 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17326 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17327 return resultobj;
17328 fail:
17329 return NULL;
17330 }
17331
17332
17333 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17334 PyObject *resultobj;
17335 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17336 wxDC *arg2 = 0 ;
17337 wxPoint result;
17338 PyObject * obj0 = 0 ;
17339 PyObject * obj1 = 0 ;
17340 char *kwnames[] = {
17341 (char *) "self",(char *) "dc", NULL
17342 };
17343
17344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17346 if (SWIG_arg_fail(1)) SWIG_fail;
17347 {
17348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17349 if (SWIG_arg_fail(2)) SWIG_fail;
17350 if (arg2 == NULL) {
17351 SWIG_null_ref("wxDC");
17352 }
17353 if (SWIG_arg_fail(2)) SWIG_fail;
17354 }
17355 {
17356 PyThreadState* __tstate = wxPyBeginAllowThreads();
17357 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17358
17359 wxPyEndAllowThreads(__tstate);
17360 if (PyErr_Occurred()) SWIG_fail;
17361 }
17362 {
17363 wxPoint * resultptr;
17364 resultptr = new wxPoint((wxPoint &)(result));
17365 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17366 }
17367 return resultobj;
17368 fail:
17369 return NULL;
17370 }
17371
17372
17373 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj;
17375 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17376 int result;
17377 PyObject * obj0 = 0 ;
17378 char *kwnames[] = {
17379 (char *) "self", NULL
17380 };
17381
17382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17384 if (SWIG_arg_fail(1)) SWIG_fail;
17385 {
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 result = (int)((wxMouseEvent const *)arg1)->GetX();
17388
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 {
17393 resultobj = SWIG_From_int((int)(result));
17394 }
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17404 int result;
17405 PyObject * obj0 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 {
17414 PyThreadState* __tstate = wxPyBeginAllowThreads();
17415 result = (int)((wxMouseEvent const *)arg1)->GetY();
17416
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
17419 }
17420 {
17421 resultobj = SWIG_From_int((int)(result));
17422 }
17423 return resultobj;
17424 fail:
17425 return NULL;
17426 }
17427
17428
17429 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17430 PyObject *resultobj;
17431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17432 int result;
17433 PyObject * obj0 = 0 ;
17434 char *kwnames[] = {
17435 (char *) "self", NULL
17436 };
17437
17438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17440 if (SWIG_arg_fail(1)) SWIG_fail;
17441 {
17442 PyThreadState* __tstate = wxPyBeginAllowThreads();
17443 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17444
17445 wxPyEndAllowThreads(__tstate);
17446 if (PyErr_Occurred()) SWIG_fail;
17447 }
17448 {
17449 resultobj = SWIG_From_int((int)(result));
17450 }
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17458 PyObject *resultobj;
17459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17460 int result;
17461 PyObject * obj0 = 0 ;
17462 char *kwnames[] = {
17463 (char *) "self", NULL
17464 };
17465
17466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17468 if (SWIG_arg_fail(1)) SWIG_fail;
17469 {
17470 PyThreadState* __tstate = wxPyBeginAllowThreads();
17471 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17472
17473 wxPyEndAllowThreads(__tstate);
17474 if (PyErr_Occurred()) SWIG_fail;
17475 }
17476 {
17477 resultobj = SWIG_From_int((int)(result));
17478 }
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17486 PyObject *resultobj;
17487 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17488 int result;
17489 PyObject * obj0 = 0 ;
17490 char *kwnames[] = {
17491 (char *) "self", NULL
17492 };
17493
17494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17496 if (SWIG_arg_fail(1)) SWIG_fail;
17497 {
17498 PyThreadState* __tstate = wxPyBeginAllowThreads();
17499 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17500
17501 wxPyEndAllowThreads(__tstate);
17502 if (PyErr_Occurred()) SWIG_fail;
17503 }
17504 {
17505 resultobj = SWIG_From_int((int)(result));
17506 }
17507 return resultobj;
17508 fail:
17509 return NULL;
17510 }
17511
17512
17513 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17514 PyObject *resultobj;
17515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17516 bool result;
17517 PyObject * obj0 = 0 ;
17518 char *kwnames[] = {
17519 (char *) "self", NULL
17520 };
17521
17522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17524 if (SWIG_arg_fail(1)) SWIG_fail;
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17528
17529 wxPyEndAllowThreads(__tstate);
17530 if (PyErr_Occurred()) SWIG_fail;
17531 }
17532 {
17533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17534 }
17535 return resultobj;
17536 fail:
17537 return NULL;
17538 }
17539
17540
17541 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17542 PyObject *resultobj;
17543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17544 int arg2 ;
17545 PyObject * obj0 = 0 ;
17546 PyObject * obj1 = 0 ;
17547 char *kwnames[] = {
17548 (char *) "self",(char *) "m_x", NULL
17549 };
17550
17551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17553 if (SWIG_arg_fail(1)) SWIG_fail;
17554 {
17555 arg2 = (int)(SWIG_As_int(obj1));
17556 if (SWIG_arg_fail(2)) SWIG_fail;
17557 }
17558 if (arg1) (arg1)->m_x = arg2;
17559
17560 Py_INCREF(Py_None); resultobj = Py_None;
17561 return resultobj;
17562 fail:
17563 return NULL;
17564 }
17565
17566
17567 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17568 PyObject *resultobj;
17569 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17570 int result;
17571 PyObject * obj0 = 0 ;
17572 char *kwnames[] = {
17573 (char *) "self", NULL
17574 };
17575
17576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17578 if (SWIG_arg_fail(1)) SWIG_fail;
17579 result = (int) ((arg1)->m_x);
17580
17581 {
17582 resultobj = SWIG_From_int((int)(result));
17583 }
17584 return resultobj;
17585 fail:
17586 return NULL;
17587 }
17588
17589
17590 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17591 PyObject *resultobj;
17592 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17593 int arg2 ;
17594 PyObject * obj0 = 0 ;
17595 PyObject * obj1 = 0 ;
17596 char *kwnames[] = {
17597 (char *) "self",(char *) "m_y", NULL
17598 };
17599
17600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17602 if (SWIG_arg_fail(1)) SWIG_fail;
17603 {
17604 arg2 = (int)(SWIG_As_int(obj1));
17605 if (SWIG_arg_fail(2)) SWIG_fail;
17606 }
17607 if (arg1) (arg1)->m_y = arg2;
17608
17609 Py_INCREF(Py_None); resultobj = Py_None;
17610 return resultobj;
17611 fail:
17612 return NULL;
17613 }
17614
17615
17616 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17617 PyObject *resultobj;
17618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17619 int result;
17620 PyObject * obj0 = 0 ;
17621 char *kwnames[] = {
17622 (char *) "self", NULL
17623 };
17624
17625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17627 if (SWIG_arg_fail(1)) SWIG_fail;
17628 result = (int) ((arg1)->m_y);
17629
17630 {
17631 resultobj = SWIG_From_int((int)(result));
17632 }
17633 return resultobj;
17634 fail:
17635 return NULL;
17636 }
17637
17638
17639 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj;
17641 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17642 bool arg2 ;
17643 PyObject * obj0 = 0 ;
17644 PyObject * obj1 = 0 ;
17645 char *kwnames[] = {
17646 (char *) "self",(char *) "m_leftDown", NULL
17647 };
17648
17649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17651 if (SWIG_arg_fail(1)) SWIG_fail;
17652 {
17653 arg2 = (bool)(SWIG_As_bool(obj1));
17654 if (SWIG_arg_fail(2)) SWIG_fail;
17655 }
17656 if (arg1) (arg1)->m_leftDown = arg2;
17657
17658 Py_INCREF(Py_None); resultobj = Py_None;
17659 return resultobj;
17660 fail:
17661 return NULL;
17662 }
17663
17664
17665 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17666 PyObject *resultobj;
17667 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17668 bool result;
17669 PyObject * obj0 = 0 ;
17670 char *kwnames[] = {
17671 (char *) "self", NULL
17672 };
17673
17674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17676 if (SWIG_arg_fail(1)) SWIG_fail;
17677 result = (bool) ((arg1)->m_leftDown);
17678
17679 {
17680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17681 }
17682 return resultobj;
17683 fail:
17684 return NULL;
17685 }
17686
17687
17688 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17689 PyObject *resultobj;
17690 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17691 bool arg2 ;
17692 PyObject * obj0 = 0 ;
17693 PyObject * obj1 = 0 ;
17694 char *kwnames[] = {
17695 (char *) "self",(char *) "m_middleDown", NULL
17696 };
17697
17698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17700 if (SWIG_arg_fail(1)) SWIG_fail;
17701 {
17702 arg2 = (bool)(SWIG_As_bool(obj1));
17703 if (SWIG_arg_fail(2)) SWIG_fail;
17704 }
17705 if (arg1) (arg1)->m_middleDown = arg2;
17706
17707 Py_INCREF(Py_None); resultobj = Py_None;
17708 return resultobj;
17709 fail:
17710 return NULL;
17711 }
17712
17713
17714 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17715 PyObject *resultobj;
17716 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17717 bool result;
17718 PyObject * obj0 = 0 ;
17719 char *kwnames[] = {
17720 (char *) "self", NULL
17721 };
17722
17723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17725 if (SWIG_arg_fail(1)) SWIG_fail;
17726 result = (bool) ((arg1)->m_middleDown);
17727
17728 {
17729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17730 }
17731 return resultobj;
17732 fail:
17733 return NULL;
17734 }
17735
17736
17737 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17738 PyObject *resultobj;
17739 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17740 bool arg2 ;
17741 PyObject * obj0 = 0 ;
17742 PyObject * obj1 = 0 ;
17743 char *kwnames[] = {
17744 (char *) "self",(char *) "m_rightDown", NULL
17745 };
17746
17747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17749 if (SWIG_arg_fail(1)) SWIG_fail;
17750 {
17751 arg2 = (bool)(SWIG_As_bool(obj1));
17752 if (SWIG_arg_fail(2)) SWIG_fail;
17753 }
17754 if (arg1) (arg1)->m_rightDown = arg2;
17755
17756 Py_INCREF(Py_None); resultobj = Py_None;
17757 return resultobj;
17758 fail:
17759 return NULL;
17760 }
17761
17762
17763 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj;
17765 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17766 bool result;
17767 PyObject * obj0 = 0 ;
17768 char *kwnames[] = {
17769 (char *) "self", NULL
17770 };
17771
17772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17774 if (SWIG_arg_fail(1)) SWIG_fail;
17775 result = (bool) ((arg1)->m_rightDown);
17776
17777 {
17778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17779 }
17780 return resultobj;
17781 fail:
17782 return NULL;
17783 }
17784
17785
17786 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17787 PyObject *resultobj;
17788 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17789 bool arg2 ;
17790 PyObject * obj0 = 0 ;
17791 PyObject * obj1 = 0 ;
17792 char *kwnames[] = {
17793 (char *) "self",(char *) "m_controlDown", NULL
17794 };
17795
17796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17798 if (SWIG_arg_fail(1)) SWIG_fail;
17799 {
17800 arg2 = (bool)(SWIG_As_bool(obj1));
17801 if (SWIG_arg_fail(2)) SWIG_fail;
17802 }
17803 if (arg1) (arg1)->m_controlDown = arg2;
17804
17805 Py_INCREF(Py_None); resultobj = Py_None;
17806 return resultobj;
17807 fail:
17808 return NULL;
17809 }
17810
17811
17812 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17813 PyObject *resultobj;
17814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17815 bool result;
17816 PyObject * obj0 = 0 ;
17817 char *kwnames[] = {
17818 (char *) "self", NULL
17819 };
17820
17821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17823 if (SWIG_arg_fail(1)) SWIG_fail;
17824 result = (bool) ((arg1)->m_controlDown);
17825
17826 {
17827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17828 }
17829 return resultobj;
17830 fail:
17831 return NULL;
17832 }
17833
17834
17835 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17836 PyObject *resultobj;
17837 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17838 bool arg2 ;
17839 PyObject * obj0 = 0 ;
17840 PyObject * obj1 = 0 ;
17841 char *kwnames[] = {
17842 (char *) "self",(char *) "m_shiftDown", NULL
17843 };
17844
17845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17847 if (SWIG_arg_fail(1)) SWIG_fail;
17848 {
17849 arg2 = (bool)(SWIG_As_bool(obj1));
17850 if (SWIG_arg_fail(2)) SWIG_fail;
17851 }
17852 if (arg1) (arg1)->m_shiftDown = arg2;
17853
17854 Py_INCREF(Py_None); resultobj = Py_None;
17855 return resultobj;
17856 fail:
17857 return NULL;
17858 }
17859
17860
17861 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17862 PyObject *resultobj;
17863 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17864 bool result;
17865 PyObject * obj0 = 0 ;
17866 char *kwnames[] = {
17867 (char *) "self", NULL
17868 };
17869
17870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17872 if (SWIG_arg_fail(1)) SWIG_fail;
17873 result = (bool) ((arg1)->m_shiftDown);
17874
17875 {
17876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17877 }
17878 return resultobj;
17879 fail:
17880 return NULL;
17881 }
17882
17883
17884 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17885 PyObject *resultobj;
17886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17887 bool arg2 ;
17888 PyObject * obj0 = 0 ;
17889 PyObject * obj1 = 0 ;
17890 char *kwnames[] = {
17891 (char *) "self",(char *) "m_altDown", NULL
17892 };
17893
17894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17896 if (SWIG_arg_fail(1)) SWIG_fail;
17897 {
17898 arg2 = (bool)(SWIG_As_bool(obj1));
17899 if (SWIG_arg_fail(2)) SWIG_fail;
17900 }
17901 if (arg1) (arg1)->m_altDown = arg2;
17902
17903 Py_INCREF(Py_None); resultobj = Py_None;
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17911 PyObject *resultobj;
17912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17913 bool result;
17914 PyObject * obj0 = 0 ;
17915 char *kwnames[] = {
17916 (char *) "self", NULL
17917 };
17918
17919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17921 if (SWIG_arg_fail(1)) SWIG_fail;
17922 result = (bool) ((arg1)->m_altDown);
17923
17924 {
17925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17926 }
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17934 PyObject *resultobj;
17935 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17936 bool arg2 ;
17937 PyObject * obj0 = 0 ;
17938 PyObject * obj1 = 0 ;
17939 char *kwnames[] = {
17940 (char *) "self",(char *) "m_metaDown", NULL
17941 };
17942
17943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17945 if (SWIG_arg_fail(1)) SWIG_fail;
17946 {
17947 arg2 = (bool)(SWIG_As_bool(obj1));
17948 if (SWIG_arg_fail(2)) SWIG_fail;
17949 }
17950 if (arg1) (arg1)->m_metaDown = arg2;
17951
17952 Py_INCREF(Py_None); resultobj = Py_None;
17953 return resultobj;
17954 fail:
17955 return NULL;
17956 }
17957
17958
17959 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17960 PyObject *resultobj;
17961 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17962 bool result;
17963 PyObject * obj0 = 0 ;
17964 char *kwnames[] = {
17965 (char *) "self", NULL
17966 };
17967
17968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17970 if (SWIG_arg_fail(1)) SWIG_fail;
17971 result = (bool) ((arg1)->m_metaDown);
17972
17973 {
17974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17975 }
17976 return resultobj;
17977 fail:
17978 return NULL;
17979 }
17980
17981
17982 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17983 PyObject *resultobj;
17984 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17985 int arg2 ;
17986 PyObject * obj0 = 0 ;
17987 PyObject * obj1 = 0 ;
17988 char *kwnames[] = {
17989 (char *) "self",(char *) "m_wheelRotation", NULL
17990 };
17991
17992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17994 if (SWIG_arg_fail(1)) SWIG_fail;
17995 {
17996 arg2 = (int)(SWIG_As_int(obj1));
17997 if (SWIG_arg_fail(2)) SWIG_fail;
17998 }
17999 if (arg1) (arg1)->m_wheelRotation = arg2;
18000
18001 Py_INCREF(Py_None); resultobj = Py_None;
18002 return resultobj;
18003 fail:
18004 return NULL;
18005 }
18006
18007
18008 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18009 PyObject *resultobj;
18010 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18011 int result;
18012 PyObject * obj0 = 0 ;
18013 char *kwnames[] = {
18014 (char *) "self", NULL
18015 };
18016
18017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18019 if (SWIG_arg_fail(1)) SWIG_fail;
18020 result = (int) ((arg1)->m_wheelRotation);
18021
18022 {
18023 resultobj = SWIG_From_int((int)(result));
18024 }
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj;
18033 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18034 int arg2 ;
18035 PyObject * obj0 = 0 ;
18036 PyObject * obj1 = 0 ;
18037 char *kwnames[] = {
18038 (char *) "self",(char *) "m_wheelDelta", NULL
18039 };
18040
18041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18043 if (SWIG_arg_fail(1)) SWIG_fail;
18044 {
18045 arg2 = (int)(SWIG_As_int(obj1));
18046 if (SWIG_arg_fail(2)) SWIG_fail;
18047 }
18048 if (arg1) (arg1)->m_wheelDelta = arg2;
18049
18050 Py_INCREF(Py_None); resultobj = Py_None;
18051 return resultobj;
18052 fail:
18053 return NULL;
18054 }
18055
18056
18057 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18058 PyObject *resultobj;
18059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18060 int result;
18061 PyObject * obj0 = 0 ;
18062 char *kwnames[] = {
18063 (char *) "self", NULL
18064 };
18065
18066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18068 if (SWIG_arg_fail(1)) SWIG_fail;
18069 result = (int) ((arg1)->m_wheelDelta);
18070
18071 {
18072 resultobj = SWIG_From_int((int)(result));
18073 }
18074 return resultobj;
18075 fail:
18076 return NULL;
18077 }
18078
18079
18080 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18081 PyObject *resultobj;
18082 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18083 int arg2 ;
18084 PyObject * obj0 = 0 ;
18085 PyObject * obj1 = 0 ;
18086 char *kwnames[] = {
18087 (char *) "self",(char *) "m_linesPerAction", NULL
18088 };
18089
18090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18092 if (SWIG_arg_fail(1)) SWIG_fail;
18093 {
18094 arg2 = (int)(SWIG_As_int(obj1));
18095 if (SWIG_arg_fail(2)) SWIG_fail;
18096 }
18097 if (arg1) (arg1)->m_linesPerAction = arg2;
18098
18099 Py_INCREF(Py_None); resultobj = Py_None;
18100 return resultobj;
18101 fail:
18102 return NULL;
18103 }
18104
18105
18106 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18107 PyObject *resultobj;
18108 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18109 int result;
18110 PyObject * obj0 = 0 ;
18111 char *kwnames[] = {
18112 (char *) "self", NULL
18113 };
18114
18115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18117 if (SWIG_arg_fail(1)) SWIG_fail;
18118 result = (int) ((arg1)->m_linesPerAction);
18119
18120 {
18121 resultobj = SWIG_From_int((int)(result));
18122 }
18123 return resultobj;
18124 fail:
18125 return NULL;
18126 }
18127
18128
18129 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18130 PyObject *obj;
18131 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18132 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18133 Py_INCREF(obj);
18134 return Py_BuildValue((char *)"");
18135 }
18136 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18137 PyObject *resultobj;
18138 int arg1 = (int) 0 ;
18139 int arg2 = (int) 0 ;
18140 wxSetCursorEvent *result;
18141 PyObject * obj0 = 0 ;
18142 PyObject * obj1 = 0 ;
18143 char *kwnames[] = {
18144 (char *) "x",(char *) "y", NULL
18145 };
18146
18147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18148 if (obj0) {
18149 {
18150 arg1 = (int)(SWIG_As_int(obj0));
18151 if (SWIG_arg_fail(1)) SWIG_fail;
18152 }
18153 }
18154 if (obj1) {
18155 {
18156 arg2 = (int)(SWIG_As_int(obj1));
18157 if (SWIG_arg_fail(2)) SWIG_fail;
18158 }
18159 }
18160 {
18161 PyThreadState* __tstate = wxPyBeginAllowThreads();
18162 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18163
18164 wxPyEndAllowThreads(__tstate);
18165 if (PyErr_Occurred()) SWIG_fail;
18166 }
18167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18168 return resultobj;
18169 fail:
18170 return NULL;
18171 }
18172
18173
18174 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18175 PyObject *resultobj;
18176 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18177 int result;
18178 PyObject * obj0 = 0 ;
18179 char *kwnames[] = {
18180 (char *) "self", NULL
18181 };
18182
18183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18185 if (SWIG_arg_fail(1)) SWIG_fail;
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18189
18190 wxPyEndAllowThreads(__tstate);
18191 if (PyErr_Occurred()) SWIG_fail;
18192 }
18193 {
18194 resultobj = SWIG_From_int((int)(result));
18195 }
18196 return resultobj;
18197 fail:
18198 return NULL;
18199 }
18200
18201
18202 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18203 PyObject *resultobj;
18204 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18205 int result;
18206 PyObject * obj0 = 0 ;
18207 char *kwnames[] = {
18208 (char *) "self", NULL
18209 };
18210
18211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18213 if (SWIG_arg_fail(1)) SWIG_fail;
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18217
18218 wxPyEndAllowThreads(__tstate);
18219 if (PyErr_Occurred()) SWIG_fail;
18220 }
18221 {
18222 resultobj = SWIG_From_int((int)(result));
18223 }
18224 return resultobj;
18225 fail:
18226 return NULL;
18227 }
18228
18229
18230 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18231 PyObject *resultobj;
18232 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18233 wxCursor *arg2 = 0 ;
18234 PyObject * obj0 = 0 ;
18235 PyObject * obj1 = 0 ;
18236 char *kwnames[] = {
18237 (char *) "self",(char *) "cursor", NULL
18238 };
18239
18240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18242 if (SWIG_arg_fail(1)) SWIG_fail;
18243 {
18244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18245 if (SWIG_arg_fail(2)) SWIG_fail;
18246 if (arg2 == NULL) {
18247 SWIG_null_ref("wxCursor");
18248 }
18249 if (SWIG_arg_fail(2)) SWIG_fail;
18250 }
18251 {
18252 PyThreadState* __tstate = wxPyBeginAllowThreads();
18253 (arg1)->SetCursor((wxCursor const &)*arg2);
18254
18255 wxPyEndAllowThreads(__tstate);
18256 if (PyErr_Occurred()) SWIG_fail;
18257 }
18258 Py_INCREF(Py_None); resultobj = Py_None;
18259 return resultobj;
18260 fail:
18261 return NULL;
18262 }
18263
18264
18265 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18266 PyObject *resultobj;
18267 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18268 wxCursor *result;
18269 PyObject * obj0 = 0 ;
18270 char *kwnames[] = {
18271 (char *) "self", NULL
18272 };
18273
18274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18276 if (SWIG_arg_fail(1)) SWIG_fail;
18277 {
18278 PyThreadState* __tstate = wxPyBeginAllowThreads();
18279 {
18280 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18281 result = (wxCursor *) &_result_ref;
18282 }
18283
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 {
18288 wxCursor* resultptr = new wxCursor(*result);
18289 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18290 }
18291 return resultobj;
18292 fail:
18293 return NULL;
18294 }
18295
18296
18297 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18298 PyObject *resultobj;
18299 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18300 bool result;
18301 PyObject * obj0 = 0 ;
18302 char *kwnames[] = {
18303 (char *) "self", NULL
18304 };
18305
18306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18308 if (SWIG_arg_fail(1)) SWIG_fail;
18309 {
18310 PyThreadState* __tstate = wxPyBeginAllowThreads();
18311 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18312
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 {
18317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18318 }
18319 return resultobj;
18320 fail:
18321 return NULL;
18322 }
18323
18324
18325 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18326 PyObject *obj;
18327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18328 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18329 Py_INCREF(obj);
18330 return Py_BuildValue((char *)"");
18331 }
18332 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18333 PyObject *resultobj;
18334 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18335 wxKeyEvent *result;
18336 PyObject * obj0 = 0 ;
18337 char *kwnames[] = {
18338 (char *) "eventType", NULL
18339 };
18340
18341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18342 if (obj0) {
18343 {
18344 arg1 = (wxEventType)(SWIG_As_int(obj0));
18345 if (SWIG_arg_fail(1)) SWIG_fail;
18346 }
18347 }
18348 {
18349 PyThreadState* __tstate = wxPyBeginAllowThreads();
18350 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18351
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18363 PyObject *resultobj;
18364 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18365 bool result;
18366 PyObject * obj0 = 0 ;
18367 char *kwnames[] = {
18368 (char *) "self", NULL
18369 };
18370
18371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18373 if (SWIG_arg_fail(1)) SWIG_fail;
18374 {
18375 PyThreadState* __tstate = wxPyBeginAllowThreads();
18376 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18377
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 {
18382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18383 }
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18391 PyObject *resultobj;
18392 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18393 bool result;
18394 PyObject * obj0 = 0 ;
18395 char *kwnames[] = {
18396 (char *) "self", NULL
18397 };
18398
18399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18401 if (SWIG_arg_fail(1)) SWIG_fail;
18402 {
18403 PyThreadState* __tstate = wxPyBeginAllowThreads();
18404 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18405
18406 wxPyEndAllowThreads(__tstate);
18407 if (PyErr_Occurred()) SWIG_fail;
18408 }
18409 {
18410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18411 }
18412 return resultobj;
18413 fail:
18414 return NULL;
18415 }
18416
18417
18418 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18419 PyObject *resultobj;
18420 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18421 bool result;
18422 PyObject * obj0 = 0 ;
18423 char *kwnames[] = {
18424 (char *) "self", NULL
18425 };
18426
18427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18429 if (SWIG_arg_fail(1)) SWIG_fail;
18430 {
18431 PyThreadState* __tstate = wxPyBeginAllowThreads();
18432 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18433
18434 wxPyEndAllowThreads(__tstate);
18435 if (PyErr_Occurred()) SWIG_fail;
18436 }
18437 {
18438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18439 }
18440 return resultobj;
18441 fail:
18442 return NULL;
18443 }
18444
18445
18446 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18447 PyObject *resultobj;
18448 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18449 bool result;
18450 PyObject * obj0 = 0 ;
18451 char *kwnames[] = {
18452 (char *) "self", NULL
18453 };
18454
18455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18457 if (SWIG_arg_fail(1)) SWIG_fail;
18458 {
18459 PyThreadState* __tstate = wxPyBeginAllowThreads();
18460 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18461
18462 wxPyEndAllowThreads(__tstate);
18463 if (PyErr_Occurred()) SWIG_fail;
18464 }
18465 {
18466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18467 }
18468 return resultobj;
18469 fail:
18470 return NULL;
18471 }
18472
18473
18474 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18475 PyObject *resultobj;
18476 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18477 bool result;
18478 PyObject * obj0 = 0 ;
18479 char *kwnames[] = {
18480 (char *) "self", NULL
18481 };
18482
18483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18485 if (SWIG_arg_fail(1)) SWIG_fail;
18486 {
18487 PyThreadState* __tstate = wxPyBeginAllowThreads();
18488 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18489
18490 wxPyEndAllowThreads(__tstate);
18491 if (PyErr_Occurred()) SWIG_fail;
18492 }
18493 {
18494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18495 }
18496 return resultobj;
18497 fail:
18498 return NULL;
18499 }
18500
18501
18502 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18503 PyObject *resultobj;
18504 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18505 bool result;
18506 PyObject * obj0 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "self", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18513 if (SWIG_arg_fail(1)) SWIG_fail;
18514 {
18515 PyThreadState* __tstate = wxPyBeginAllowThreads();
18516 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18517
18518 wxPyEndAllowThreads(__tstate);
18519 if (PyErr_Occurred()) SWIG_fail;
18520 }
18521 {
18522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18523 }
18524 return resultobj;
18525 fail:
18526 return NULL;
18527 }
18528
18529
18530 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18531 PyObject *resultobj;
18532 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18533 int result;
18534 PyObject * obj0 = 0 ;
18535 char *kwnames[] = {
18536 (char *) "self", NULL
18537 };
18538
18539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18541 if (SWIG_arg_fail(1)) SWIG_fail;
18542 {
18543 PyThreadState* __tstate = wxPyBeginAllowThreads();
18544 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18545
18546 wxPyEndAllowThreads(__tstate);
18547 if (PyErr_Occurred()) SWIG_fail;
18548 }
18549 {
18550 resultobj = SWIG_From_int((int)(result));
18551 }
18552 return resultobj;
18553 fail:
18554 return NULL;
18555 }
18556
18557
18558 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18559 PyObject *resultobj;
18560 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18561 int result;
18562 PyObject * obj0 = 0 ;
18563 char *kwnames[] = {
18564 (char *) "self", NULL
18565 };
18566
18567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18569 if (SWIG_arg_fail(1)) SWIG_fail;
18570 {
18571 PyThreadState* __tstate = wxPyBeginAllowThreads();
18572 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18573
18574 wxPyEndAllowThreads(__tstate);
18575 if (PyErr_Occurred()) SWIG_fail;
18576 }
18577 {
18578 resultobj = SWIG_From_int((int)(result));
18579 }
18580 return resultobj;
18581 fail:
18582 return NULL;
18583 }
18584
18585
18586 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18587 PyObject *resultobj;
18588 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18589 unsigned int result;
18590 PyObject * obj0 = 0 ;
18591 char *kwnames[] = {
18592 (char *) "self", NULL
18593 };
18594
18595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18597 if (SWIG_arg_fail(1)) SWIG_fail;
18598 {
18599 PyThreadState* __tstate = wxPyBeginAllowThreads();
18600 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18601
18602 wxPyEndAllowThreads(__tstate);
18603 if (PyErr_Occurred()) SWIG_fail;
18604 }
18605 {
18606 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18607 }
18608 return resultobj;
18609 fail:
18610 return NULL;
18611 }
18612
18613
18614 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18615 PyObject *resultobj;
18616 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18617 unsigned int result;
18618 PyObject * obj0 = 0 ;
18619 char *kwnames[] = {
18620 (char *) "self", NULL
18621 };
18622
18623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18625 if (SWIG_arg_fail(1)) SWIG_fail;
18626 {
18627 PyThreadState* __tstate = wxPyBeginAllowThreads();
18628 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18629
18630 wxPyEndAllowThreads(__tstate);
18631 if (PyErr_Occurred()) SWIG_fail;
18632 }
18633 {
18634 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18635 }
18636 return resultobj;
18637 fail:
18638 return NULL;
18639 }
18640
18641
18642 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18643 PyObject *resultobj;
18644 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18645 wxPoint result;
18646 PyObject * obj0 = 0 ;
18647 char *kwnames[] = {
18648 (char *) "self", NULL
18649 };
18650
18651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18653 if (SWIG_arg_fail(1)) SWIG_fail;
18654 {
18655 PyThreadState* __tstate = wxPyBeginAllowThreads();
18656 result = (arg1)->GetPosition();
18657
18658 wxPyEndAllowThreads(__tstate);
18659 if (PyErr_Occurred()) SWIG_fail;
18660 }
18661 {
18662 wxPoint * resultptr;
18663 resultptr = new wxPoint((wxPoint &)(result));
18664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18665 }
18666 return resultobj;
18667 fail:
18668 return NULL;
18669 }
18670
18671
18672 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18673 PyObject *resultobj;
18674 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18675 long *arg2 = (long *) 0 ;
18676 long *arg3 = (long *) 0 ;
18677 long temp2 ;
18678 int res2 = 0 ;
18679 long temp3 ;
18680 int res3 = 0 ;
18681 PyObject * obj0 = 0 ;
18682 char *kwnames[] = {
18683 (char *) "self", NULL
18684 };
18685
18686 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18687 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18690 if (SWIG_arg_fail(1)) SWIG_fail;
18691 {
18692 PyThreadState* __tstate = wxPyBeginAllowThreads();
18693 (arg1)->GetPosition(arg2,arg3);
18694
18695 wxPyEndAllowThreads(__tstate);
18696 if (PyErr_Occurred()) SWIG_fail;
18697 }
18698 Py_INCREF(Py_None); resultobj = Py_None;
18699 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18700 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18701 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18702 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18703 return resultobj;
18704 fail:
18705 return NULL;
18706 }
18707
18708
18709 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18710 PyObject *resultobj;
18711 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18712 int result;
18713 PyObject * obj0 = 0 ;
18714 char *kwnames[] = {
18715 (char *) "self", NULL
18716 };
18717
18718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18720 if (SWIG_arg_fail(1)) SWIG_fail;
18721 {
18722 PyThreadState* __tstate = wxPyBeginAllowThreads();
18723 result = (int)((wxKeyEvent const *)arg1)->GetX();
18724
18725 wxPyEndAllowThreads(__tstate);
18726 if (PyErr_Occurred()) SWIG_fail;
18727 }
18728 {
18729 resultobj = SWIG_From_int((int)(result));
18730 }
18731 return resultobj;
18732 fail:
18733 return NULL;
18734 }
18735
18736
18737 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18738 PyObject *resultobj;
18739 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18740 int result;
18741 PyObject * obj0 = 0 ;
18742 char *kwnames[] = {
18743 (char *) "self", NULL
18744 };
18745
18746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18748 if (SWIG_arg_fail(1)) SWIG_fail;
18749 {
18750 PyThreadState* __tstate = wxPyBeginAllowThreads();
18751 result = (int)((wxKeyEvent const *)arg1)->GetY();
18752
18753 wxPyEndAllowThreads(__tstate);
18754 if (PyErr_Occurred()) SWIG_fail;
18755 }
18756 {
18757 resultobj = SWIG_From_int((int)(result));
18758 }
18759 return resultobj;
18760 fail:
18761 return NULL;
18762 }
18763
18764
18765 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18766 PyObject *resultobj;
18767 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18768 int arg2 ;
18769 PyObject * obj0 = 0 ;
18770 PyObject * obj1 = 0 ;
18771 char *kwnames[] = {
18772 (char *) "self",(char *) "m_x", NULL
18773 };
18774
18775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18777 if (SWIG_arg_fail(1)) SWIG_fail;
18778 {
18779 arg2 = (int)(SWIG_As_int(obj1));
18780 if (SWIG_arg_fail(2)) SWIG_fail;
18781 }
18782 if (arg1) (arg1)->m_x = arg2;
18783
18784 Py_INCREF(Py_None); resultobj = Py_None;
18785 return resultobj;
18786 fail:
18787 return NULL;
18788 }
18789
18790
18791 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18792 PyObject *resultobj;
18793 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18794 int result;
18795 PyObject * obj0 = 0 ;
18796 char *kwnames[] = {
18797 (char *) "self", NULL
18798 };
18799
18800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18802 if (SWIG_arg_fail(1)) SWIG_fail;
18803 result = (int) ((arg1)->m_x);
18804
18805 {
18806 resultobj = SWIG_From_int((int)(result));
18807 }
18808 return resultobj;
18809 fail:
18810 return NULL;
18811 }
18812
18813
18814 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18815 PyObject *resultobj;
18816 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18817 int arg2 ;
18818 PyObject * obj0 = 0 ;
18819 PyObject * obj1 = 0 ;
18820 char *kwnames[] = {
18821 (char *) "self",(char *) "m_y", NULL
18822 };
18823
18824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18826 if (SWIG_arg_fail(1)) SWIG_fail;
18827 {
18828 arg2 = (int)(SWIG_As_int(obj1));
18829 if (SWIG_arg_fail(2)) SWIG_fail;
18830 }
18831 if (arg1) (arg1)->m_y = arg2;
18832
18833 Py_INCREF(Py_None); resultobj = Py_None;
18834 return resultobj;
18835 fail:
18836 return NULL;
18837 }
18838
18839
18840 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18841 PyObject *resultobj;
18842 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18843 int result;
18844 PyObject * obj0 = 0 ;
18845 char *kwnames[] = {
18846 (char *) "self", NULL
18847 };
18848
18849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18851 if (SWIG_arg_fail(1)) SWIG_fail;
18852 result = (int) ((arg1)->m_y);
18853
18854 {
18855 resultobj = SWIG_From_int((int)(result));
18856 }
18857 return resultobj;
18858 fail:
18859 return NULL;
18860 }
18861
18862
18863 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18864 PyObject *resultobj;
18865 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18866 long arg2 ;
18867 PyObject * obj0 = 0 ;
18868 PyObject * obj1 = 0 ;
18869 char *kwnames[] = {
18870 (char *) "self",(char *) "m_keyCode", NULL
18871 };
18872
18873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18875 if (SWIG_arg_fail(1)) SWIG_fail;
18876 {
18877 arg2 = (long)(SWIG_As_long(obj1));
18878 if (SWIG_arg_fail(2)) SWIG_fail;
18879 }
18880 if (arg1) (arg1)->m_keyCode = arg2;
18881
18882 Py_INCREF(Py_None); resultobj = Py_None;
18883 return resultobj;
18884 fail:
18885 return NULL;
18886 }
18887
18888
18889 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18890 PyObject *resultobj;
18891 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18892 long result;
18893 PyObject * obj0 = 0 ;
18894 char *kwnames[] = {
18895 (char *) "self", NULL
18896 };
18897
18898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18900 if (SWIG_arg_fail(1)) SWIG_fail;
18901 result = (long) ((arg1)->m_keyCode);
18902
18903 {
18904 resultobj = SWIG_From_long((long)(result));
18905 }
18906 return resultobj;
18907 fail:
18908 return NULL;
18909 }
18910
18911
18912 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18913 PyObject *resultobj;
18914 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18915 bool arg2 ;
18916 PyObject * obj0 = 0 ;
18917 PyObject * obj1 = 0 ;
18918 char *kwnames[] = {
18919 (char *) "self",(char *) "m_controlDown", NULL
18920 };
18921
18922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18924 if (SWIG_arg_fail(1)) SWIG_fail;
18925 {
18926 arg2 = (bool)(SWIG_As_bool(obj1));
18927 if (SWIG_arg_fail(2)) SWIG_fail;
18928 }
18929 if (arg1) (arg1)->m_controlDown = arg2;
18930
18931 Py_INCREF(Py_None); resultobj = Py_None;
18932 return resultobj;
18933 fail:
18934 return NULL;
18935 }
18936
18937
18938 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18939 PyObject *resultobj;
18940 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18941 bool result;
18942 PyObject * obj0 = 0 ;
18943 char *kwnames[] = {
18944 (char *) "self", NULL
18945 };
18946
18947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18949 if (SWIG_arg_fail(1)) SWIG_fail;
18950 result = (bool) ((arg1)->m_controlDown);
18951
18952 {
18953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18954 }
18955 return resultobj;
18956 fail:
18957 return NULL;
18958 }
18959
18960
18961 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18962 PyObject *resultobj;
18963 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18964 bool arg2 ;
18965 PyObject * obj0 = 0 ;
18966 PyObject * obj1 = 0 ;
18967 char *kwnames[] = {
18968 (char *) "self",(char *) "m_shiftDown", NULL
18969 };
18970
18971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18973 if (SWIG_arg_fail(1)) SWIG_fail;
18974 {
18975 arg2 = (bool)(SWIG_As_bool(obj1));
18976 if (SWIG_arg_fail(2)) SWIG_fail;
18977 }
18978 if (arg1) (arg1)->m_shiftDown = arg2;
18979
18980 Py_INCREF(Py_None); resultobj = Py_None;
18981 return resultobj;
18982 fail:
18983 return NULL;
18984 }
18985
18986
18987 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18988 PyObject *resultobj;
18989 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18990 bool result;
18991 PyObject * obj0 = 0 ;
18992 char *kwnames[] = {
18993 (char *) "self", NULL
18994 };
18995
18996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18998 if (SWIG_arg_fail(1)) SWIG_fail;
18999 result = (bool) ((arg1)->m_shiftDown);
19000
19001 {
19002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19003 }
19004 return resultobj;
19005 fail:
19006 return NULL;
19007 }
19008
19009
19010 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19011 PyObject *resultobj;
19012 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19013 bool arg2 ;
19014 PyObject * obj0 = 0 ;
19015 PyObject * obj1 = 0 ;
19016 char *kwnames[] = {
19017 (char *) "self",(char *) "m_altDown", NULL
19018 };
19019
19020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19022 if (SWIG_arg_fail(1)) SWIG_fail;
19023 {
19024 arg2 = (bool)(SWIG_As_bool(obj1));
19025 if (SWIG_arg_fail(2)) SWIG_fail;
19026 }
19027 if (arg1) (arg1)->m_altDown = arg2;
19028
19029 Py_INCREF(Py_None); resultobj = Py_None;
19030 return resultobj;
19031 fail:
19032 return NULL;
19033 }
19034
19035
19036 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19037 PyObject *resultobj;
19038 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19039 bool result;
19040 PyObject * obj0 = 0 ;
19041 char *kwnames[] = {
19042 (char *) "self", NULL
19043 };
19044
19045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19047 if (SWIG_arg_fail(1)) SWIG_fail;
19048 result = (bool) ((arg1)->m_altDown);
19049
19050 {
19051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19052 }
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19060 PyObject *resultobj;
19061 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19062 bool arg2 ;
19063 PyObject * obj0 = 0 ;
19064 PyObject * obj1 = 0 ;
19065 char *kwnames[] = {
19066 (char *) "self",(char *) "m_metaDown", NULL
19067 };
19068
19069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19071 if (SWIG_arg_fail(1)) SWIG_fail;
19072 {
19073 arg2 = (bool)(SWIG_As_bool(obj1));
19074 if (SWIG_arg_fail(2)) SWIG_fail;
19075 }
19076 if (arg1) (arg1)->m_metaDown = arg2;
19077
19078 Py_INCREF(Py_None); resultobj = Py_None;
19079 return resultobj;
19080 fail:
19081 return NULL;
19082 }
19083
19084
19085 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19086 PyObject *resultobj;
19087 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19088 bool result;
19089 PyObject * obj0 = 0 ;
19090 char *kwnames[] = {
19091 (char *) "self", NULL
19092 };
19093
19094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19096 if (SWIG_arg_fail(1)) SWIG_fail;
19097 result = (bool) ((arg1)->m_metaDown);
19098
19099 {
19100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19101 }
19102 return resultobj;
19103 fail:
19104 return NULL;
19105 }
19106
19107
19108 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19109 PyObject *resultobj;
19110 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19111 bool arg2 ;
19112 PyObject * obj0 = 0 ;
19113 PyObject * obj1 = 0 ;
19114 char *kwnames[] = {
19115 (char *) "self",(char *) "m_scanCode", NULL
19116 };
19117
19118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19120 if (SWIG_arg_fail(1)) SWIG_fail;
19121 {
19122 arg2 = (bool)(SWIG_As_bool(obj1));
19123 if (SWIG_arg_fail(2)) SWIG_fail;
19124 }
19125 if (arg1) (arg1)->m_scanCode = arg2;
19126
19127 Py_INCREF(Py_None); resultobj = Py_None;
19128 return resultobj;
19129 fail:
19130 return NULL;
19131 }
19132
19133
19134 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19135 PyObject *resultobj;
19136 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19137 bool result;
19138 PyObject * obj0 = 0 ;
19139 char *kwnames[] = {
19140 (char *) "self", NULL
19141 };
19142
19143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19145 if (SWIG_arg_fail(1)) SWIG_fail;
19146 result = (bool) ((arg1)->m_scanCode);
19147
19148 {
19149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19150 }
19151 return resultobj;
19152 fail:
19153 return NULL;
19154 }
19155
19156
19157 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19158 PyObject *resultobj;
19159 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19160 unsigned int arg2 ;
19161 PyObject * obj0 = 0 ;
19162 PyObject * obj1 = 0 ;
19163 char *kwnames[] = {
19164 (char *) "self",(char *) "m_rawCode", NULL
19165 };
19166
19167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19169 if (SWIG_arg_fail(1)) SWIG_fail;
19170 {
19171 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19172 if (SWIG_arg_fail(2)) SWIG_fail;
19173 }
19174 if (arg1) (arg1)->m_rawCode = arg2;
19175
19176 Py_INCREF(Py_None); resultobj = Py_None;
19177 return resultobj;
19178 fail:
19179 return NULL;
19180 }
19181
19182
19183 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19184 PyObject *resultobj;
19185 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19186 unsigned int result;
19187 PyObject * obj0 = 0 ;
19188 char *kwnames[] = {
19189 (char *) "self", NULL
19190 };
19191
19192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19194 if (SWIG_arg_fail(1)) SWIG_fail;
19195 result = (unsigned int) ((arg1)->m_rawCode);
19196
19197 {
19198 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19199 }
19200 return resultobj;
19201 fail:
19202 return NULL;
19203 }
19204
19205
19206 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19207 PyObject *resultobj;
19208 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19209 unsigned int arg2 ;
19210 PyObject * obj0 = 0 ;
19211 PyObject * obj1 = 0 ;
19212 char *kwnames[] = {
19213 (char *) "self",(char *) "m_rawFlags", NULL
19214 };
19215
19216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19218 if (SWIG_arg_fail(1)) SWIG_fail;
19219 {
19220 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19221 if (SWIG_arg_fail(2)) SWIG_fail;
19222 }
19223 if (arg1) (arg1)->m_rawFlags = arg2;
19224
19225 Py_INCREF(Py_None); resultobj = Py_None;
19226 return resultobj;
19227 fail:
19228 return NULL;
19229 }
19230
19231
19232 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19233 PyObject *resultobj;
19234 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19235 unsigned int result;
19236 PyObject * obj0 = 0 ;
19237 char *kwnames[] = {
19238 (char *) "self", NULL
19239 };
19240
19241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19243 if (SWIG_arg_fail(1)) SWIG_fail;
19244 result = (unsigned int) ((arg1)->m_rawFlags);
19245
19246 {
19247 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19248 }
19249 return resultobj;
19250 fail:
19251 return NULL;
19252 }
19253
19254
19255 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19256 PyObject *obj;
19257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19258 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19259 Py_INCREF(obj);
19260 return Py_BuildValue((char *)"");
19261 }
19262 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19263 PyObject *resultobj;
19264 wxSize const &arg1_defvalue = wxDefaultSize ;
19265 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19266 int arg2 = (int) 0 ;
19267 wxSizeEvent *result;
19268 wxSize temp1 ;
19269 PyObject * obj0 = 0 ;
19270 PyObject * obj1 = 0 ;
19271 char *kwnames[] = {
19272 (char *) "sz",(char *) "winid", NULL
19273 };
19274
19275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19276 if (obj0) {
19277 {
19278 arg1 = &temp1;
19279 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19280 }
19281 }
19282 if (obj1) {
19283 {
19284 arg2 = (int)(SWIG_As_int(obj1));
19285 if (SWIG_arg_fail(2)) SWIG_fail;
19286 }
19287 }
19288 {
19289 PyThreadState* __tstate = wxPyBeginAllowThreads();
19290 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19291
19292 wxPyEndAllowThreads(__tstate);
19293 if (PyErr_Occurred()) SWIG_fail;
19294 }
19295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19296 return resultobj;
19297 fail:
19298 return NULL;
19299 }
19300
19301
19302 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19303 PyObject *resultobj;
19304 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19305 wxSize result;
19306 PyObject * obj0 = 0 ;
19307 char *kwnames[] = {
19308 (char *) "self", NULL
19309 };
19310
19311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19313 if (SWIG_arg_fail(1)) SWIG_fail;
19314 {
19315 PyThreadState* __tstate = wxPyBeginAllowThreads();
19316 result = ((wxSizeEvent const *)arg1)->GetSize();
19317
19318 wxPyEndAllowThreads(__tstate);
19319 if (PyErr_Occurred()) SWIG_fail;
19320 }
19321 {
19322 wxSize * resultptr;
19323 resultptr = new wxSize((wxSize &)(result));
19324 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19325 }
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19333 PyObject *resultobj;
19334 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19335 wxRect result;
19336 PyObject * obj0 = 0 ;
19337 char *kwnames[] = {
19338 (char *) "self", NULL
19339 };
19340
19341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19343 if (SWIG_arg_fail(1)) SWIG_fail;
19344 {
19345 PyThreadState* __tstate = wxPyBeginAllowThreads();
19346 result = ((wxSizeEvent const *)arg1)->GetRect();
19347
19348 wxPyEndAllowThreads(__tstate);
19349 if (PyErr_Occurred()) SWIG_fail;
19350 }
19351 {
19352 wxRect * resultptr;
19353 resultptr = new wxRect((wxRect &)(result));
19354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19355 }
19356 return resultobj;
19357 fail:
19358 return NULL;
19359 }
19360
19361
19362 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19363 PyObject *resultobj;
19364 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19365 wxRect arg2 ;
19366 PyObject * obj0 = 0 ;
19367 PyObject * obj1 = 0 ;
19368 char *kwnames[] = {
19369 (char *) "self",(char *) "rect", NULL
19370 };
19371
19372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19374 if (SWIG_arg_fail(1)) SWIG_fail;
19375 {
19376 wxRect * argp;
19377 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19378 if (SWIG_arg_fail(2)) SWIG_fail;
19379 if (argp == NULL) {
19380 SWIG_null_ref("wxRect");
19381 }
19382 if (SWIG_arg_fail(2)) SWIG_fail;
19383 arg2 = *argp;
19384 }
19385 {
19386 PyThreadState* __tstate = wxPyBeginAllowThreads();
19387 (arg1)->SetRect(arg2);
19388
19389 wxPyEndAllowThreads(__tstate);
19390 if (PyErr_Occurred()) SWIG_fail;
19391 }
19392 Py_INCREF(Py_None); resultobj = Py_None;
19393 return resultobj;
19394 fail:
19395 return NULL;
19396 }
19397
19398
19399 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19400 PyObject *resultobj;
19401 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19402 wxSize arg2 ;
19403 PyObject * obj0 = 0 ;
19404 PyObject * obj1 = 0 ;
19405 char *kwnames[] = {
19406 (char *) "self",(char *) "size", NULL
19407 };
19408
19409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19411 if (SWIG_arg_fail(1)) SWIG_fail;
19412 {
19413 wxSize * argp;
19414 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19415 if (SWIG_arg_fail(2)) SWIG_fail;
19416 if (argp == NULL) {
19417 SWIG_null_ref("wxSize");
19418 }
19419 if (SWIG_arg_fail(2)) SWIG_fail;
19420 arg2 = *argp;
19421 }
19422 {
19423 PyThreadState* __tstate = wxPyBeginAllowThreads();
19424 wxSizeEvent_SetSize(arg1,arg2);
19425
19426 wxPyEndAllowThreads(__tstate);
19427 if (PyErr_Occurred()) SWIG_fail;
19428 }
19429 Py_INCREF(Py_None); resultobj = Py_None;
19430 return resultobj;
19431 fail:
19432 return NULL;
19433 }
19434
19435
19436 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19437 PyObject *resultobj;
19438 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19439 wxSize *arg2 = (wxSize *) 0 ;
19440 PyObject * obj0 = 0 ;
19441 PyObject * obj1 = 0 ;
19442 char *kwnames[] = {
19443 (char *) "self",(char *) "m_size", NULL
19444 };
19445
19446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19448 if (SWIG_arg_fail(1)) SWIG_fail;
19449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19450 if (SWIG_arg_fail(2)) SWIG_fail;
19451 if (arg1) (arg1)->m_size = *arg2;
19452
19453 Py_INCREF(Py_None); resultobj = Py_None;
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19461 PyObject *resultobj;
19462 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19463 wxSize *result;
19464 PyObject * obj0 = 0 ;
19465 char *kwnames[] = {
19466 (char *) "self", NULL
19467 };
19468
19469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19471 if (SWIG_arg_fail(1)) SWIG_fail;
19472 result = (wxSize *)& ((arg1)->m_size);
19473
19474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19475 return resultobj;
19476 fail:
19477 return NULL;
19478 }
19479
19480
19481 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19482 PyObject *resultobj;
19483 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19484 wxRect *arg2 = (wxRect *) 0 ;
19485 PyObject * obj0 = 0 ;
19486 PyObject * obj1 = 0 ;
19487 char *kwnames[] = {
19488 (char *) "self",(char *) "m_rect", NULL
19489 };
19490
19491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19493 if (SWIG_arg_fail(1)) SWIG_fail;
19494 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19495 if (SWIG_arg_fail(2)) SWIG_fail;
19496 if (arg1) (arg1)->m_rect = *arg2;
19497
19498 Py_INCREF(Py_None); resultobj = Py_None;
19499 return resultobj;
19500 fail:
19501 return NULL;
19502 }
19503
19504
19505 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19506 PyObject *resultobj;
19507 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19508 wxRect *result;
19509 PyObject * obj0 = 0 ;
19510 char *kwnames[] = {
19511 (char *) "self", NULL
19512 };
19513
19514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19516 if (SWIG_arg_fail(1)) SWIG_fail;
19517 result = (wxRect *)& ((arg1)->m_rect);
19518
19519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19520 return resultobj;
19521 fail:
19522 return NULL;
19523 }
19524
19525
19526 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19527 PyObject *obj;
19528 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19529 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19530 Py_INCREF(obj);
19531 return Py_BuildValue((char *)"");
19532 }
19533 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19534 PyObject *resultobj;
19535 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19536 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19537 int arg2 = (int) 0 ;
19538 wxMoveEvent *result;
19539 wxPoint temp1 ;
19540 PyObject * obj0 = 0 ;
19541 PyObject * obj1 = 0 ;
19542 char *kwnames[] = {
19543 (char *) "pos",(char *) "winid", NULL
19544 };
19545
19546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19547 if (obj0) {
19548 {
19549 arg1 = &temp1;
19550 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19551 }
19552 }
19553 if (obj1) {
19554 {
19555 arg2 = (int)(SWIG_As_int(obj1));
19556 if (SWIG_arg_fail(2)) SWIG_fail;
19557 }
19558 }
19559 {
19560 PyThreadState* __tstate = wxPyBeginAllowThreads();
19561 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19562
19563 wxPyEndAllowThreads(__tstate);
19564 if (PyErr_Occurred()) SWIG_fail;
19565 }
19566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19567 return resultobj;
19568 fail:
19569 return NULL;
19570 }
19571
19572
19573 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19574 PyObject *resultobj;
19575 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19576 wxPoint result;
19577 PyObject * obj0 = 0 ;
19578 char *kwnames[] = {
19579 (char *) "self", NULL
19580 };
19581
19582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19584 if (SWIG_arg_fail(1)) SWIG_fail;
19585 {
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = ((wxMoveEvent const *)arg1)->GetPosition();
19588
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 {
19593 wxPoint * resultptr;
19594 resultptr = new wxPoint((wxPoint &)(result));
19595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19596 }
19597 return resultobj;
19598 fail:
19599 return NULL;
19600 }
19601
19602
19603 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19604 PyObject *resultobj;
19605 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19606 wxRect result;
19607 PyObject * obj0 = 0 ;
19608 char *kwnames[] = {
19609 (char *) "self", NULL
19610 };
19611
19612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19614 if (SWIG_arg_fail(1)) SWIG_fail;
19615 {
19616 PyThreadState* __tstate = wxPyBeginAllowThreads();
19617 result = ((wxMoveEvent const *)arg1)->GetRect();
19618
19619 wxPyEndAllowThreads(__tstate);
19620 if (PyErr_Occurred()) SWIG_fail;
19621 }
19622 {
19623 wxRect * resultptr;
19624 resultptr = new wxRect((wxRect &)(result));
19625 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19626 }
19627 return resultobj;
19628 fail:
19629 return NULL;
19630 }
19631
19632
19633 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19634 PyObject *resultobj;
19635 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19636 wxRect *arg2 = 0 ;
19637 wxRect temp2 ;
19638 PyObject * obj0 = 0 ;
19639 PyObject * obj1 = 0 ;
19640 char *kwnames[] = {
19641 (char *) "self",(char *) "rect", NULL
19642 };
19643
19644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19646 if (SWIG_arg_fail(1)) SWIG_fail;
19647 {
19648 arg2 = &temp2;
19649 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19650 }
19651 {
19652 PyThreadState* __tstate = wxPyBeginAllowThreads();
19653 (arg1)->SetRect((wxRect const &)*arg2);
19654
19655 wxPyEndAllowThreads(__tstate);
19656 if (PyErr_Occurred()) SWIG_fail;
19657 }
19658 Py_INCREF(Py_None); resultobj = Py_None;
19659 return resultobj;
19660 fail:
19661 return NULL;
19662 }
19663
19664
19665 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19666 PyObject *resultobj;
19667 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19668 wxPoint *arg2 = 0 ;
19669 wxPoint temp2 ;
19670 PyObject * obj0 = 0 ;
19671 PyObject * obj1 = 0 ;
19672 char *kwnames[] = {
19673 (char *) "self",(char *) "pos", NULL
19674 };
19675
19676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19678 if (SWIG_arg_fail(1)) SWIG_fail;
19679 {
19680 arg2 = &temp2;
19681 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19682 }
19683 {
19684 PyThreadState* __tstate = wxPyBeginAllowThreads();
19685 (arg1)->SetPosition((wxPoint const &)*arg2);
19686
19687 wxPyEndAllowThreads(__tstate);
19688 if (PyErr_Occurred()) SWIG_fail;
19689 }
19690 Py_INCREF(Py_None); resultobj = Py_None;
19691 return resultobj;
19692 fail:
19693 return NULL;
19694 }
19695
19696
19697 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19698 PyObject *obj;
19699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19700 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19701 Py_INCREF(obj);
19702 return Py_BuildValue((char *)"");
19703 }
19704 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19705 PyObject *resultobj;
19706 int arg1 = (int) 0 ;
19707 wxPaintEvent *result;
19708 PyObject * obj0 = 0 ;
19709 char *kwnames[] = {
19710 (char *) "Id", NULL
19711 };
19712
19713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19714 if (obj0) {
19715 {
19716 arg1 = (int)(SWIG_As_int(obj0));
19717 if (SWIG_arg_fail(1)) SWIG_fail;
19718 }
19719 }
19720 {
19721 PyThreadState* __tstate = wxPyBeginAllowThreads();
19722 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19723
19724 wxPyEndAllowThreads(__tstate);
19725 if (PyErr_Occurred()) SWIG_fail;
19726 }
19727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19728 return resultobj;
19729 fail:
19730 return NULL;
19731 }
19732
19733
19734 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19735 PyObject *obj;
19736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19737 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19738 Py_INCREF(obj);
19739 return Py_BuildValue((char *)"");
19740 }
19741 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19742 PyObject *resultobj;
19743 int arg1 = (int) 0 ;
19744 wxNcPaintEvent *result;
19745 PyObject * obj0 = 0 ;
19746 char *kwnames[] = {
19747 (char *) "winid", NULL
19748 };
19749
19750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19751 if (obj0) {
19752 {
19753 arg1 = (int)(SWIG_As_int(obj0));
19754 if (SWIG_arg_fail(1)) SWIG_fail;
19755 }
19756 }
19757 {
19758 PyThreadState* __tstate = wxPyBeginAllowThreads();
19759 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19760
19761 wxPyEndAllowThreads(__tstate);
19762 if (PyErr_Occurred()) SWIG_fail;
19763 }
19764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19765 return resultobj;
19766 fail:
19767 return NULL;
19768 }
19769
19770
19771 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19772 PyObject *obj;
19773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19774 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19775 Py_INCREF(obj);
19776 return Py_BuildValue((char *)"");
19777 }
19778 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19779 PyObject *resultobj;
19780 int arg1 = (int) 0 ;
19781 wxDC *arg2 = (wxDC *) NULL ;
19782 wxEraseEvent *result;
19783 PyObject * obj0 = 0 ;
19784 PyObject * obj1 = 0 ;
19785 char *kwnames[] = {
19786 (char *) "Id",(char *) "dc", NULL
19787 };
19788
19789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19790 if (obj0) {
19791 {
19792 arg1 = (int)(SWIG_As_int(obj0));
19793 if (SWIG_arg_fail(1)) SWIG_fail;
19794 }
19795 }
19796 if (obj1) {
19797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19798 if (SWIG_arg_fail(2)) SWIG_fail;
19799 }
19800 {
19801 PyThreadState* __tstate = wxPyBeginAllowThreads();
19802 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19803
19804 wxPyEndAllowThreads(__tstate);
19805 if (PyErr_Occurred()) SWIG_fail;
19806 }
19807 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19815 PyObject *resultobj;
19816 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19817 wxDC *result;
19818 PyObject * obj0 = 0 ;
19819 char *kwnames[] = {
19820 (char *) "self", NULL
19821 };
19822
19823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19825 if (SWIG_arg_fail(1)) SWIG_fail;
19826 {
19827 PyThreadState* __tstate = wxPyBeginAllowThreads();
19828 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19829
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 {
19834 resultobj = wxPyMake_wxObject(result, 0);
19835 }
19836 return resultobj;
19837 fail:
19838 return NULL;
19839 }
19840
19841
19842 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19843 PyObject *obj;
19844 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19845 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19846 Py_INCREF(obj);
19847 return Py_BuildValue((char *)"");
19848 }
19849 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19850 PyObject *resultobj;
19851 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19852 int arg2 = (int) 0 ;
19853 wxFocusEvent *result;
19854 PyObject * obj0 = 0 ;
19855 PyObject * obj1 = 0 ;
19856 char *kwnames[] = {
19857 (char *) "type",(char *) "winid", NULL
19858 };
19859
19860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19861 if (obj0) {
19862 {
19863 arg1 = (wxEventType)(SWIG_As_int(obj0));
19864 if (SWIG_arg_fail(1)) SWIG_fail;
19865 }
19866 }
19867 if (obj1) {
19868 {
19869 arg2 = (int)(SWIG_As_int(obj1));
19870 if (SWIG_arg_fail(2)) SWIG_fail;
19871 }
19872 }
19873 {
19874 PyThreadState* __tstate = wxPyBeginAllowThreads();
19875 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19876
19877 wxPyEndAllowThreads(__tstate);
19878 if (PyErr_Occurred()) SWIG_fail;
19879 }
19880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19888 PyObject *resultobj;
19889 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19890 wxWindow *result;
19891 PyObject * obj0 = 0 ;
19892 char *kwnames[] = {
19893 (char *) "self", NULL
19894 };
19895
19896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19898 if (SWIG_arg_fail(1)) SWIG_fail;
19899 {
19900 PyThreadState* __tstate = wxPyBeginAllowThreads();
19901 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19902
19903 wxPyEndAllowThreads(__tstate);
19904 if (PyErr_Occurred()) SWIG_fail;
19905 }
19906 {
19907 resultobj = wxPyMake_wxObject(result, 0);
19908 }
19909 return resultobj;
19910 fail:
19911 return NULL;
19912 }
19913
19914
19915 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19916 PyObject *resultobj;
19917 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19918 wxWindow *arg2 = (wxWindow *) 0 ;
19919 PyObject * obj0 = 0 ;
19920 PyObject * obj1 = 0 ;
19921 char *kwnames[] = {
19922 (char *) "self",(char *) "win", NULL
19923 };
19924
19925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19927 if (SWIG_arg_fail(1)) SWIG_fail;
19928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19929 if (SWIG_arg_fail(2)) SWIG_fail;
19930 {
19931 PyThreadState* __tstate = wxPyBeginAllowThreads();
19932 (arg1)->SetWindow(arg2);
19933
19934 wxPyEndAllowThreads(__tstate);
19935 if (PyErr_Occurred()) SWIG_fail;
19936 }
19937 Py_INCREF(Py_None); resultobj = Py_None;
19938 return resultobj;
19939 fail:
19940 return NULL;
19941 }
19942
19943
19944 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19945 PyObject *obj;
19946 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19947 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19948 Py_INCREF(obj);
19949 return Py_BuildValue((char *)"");
19950 }
19951 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19952 PyObject *resultobj;
19953 wxWindow *arg1 = (wxWindow *) NULL ;
19954 wxChildFocusEvent *result;
19955 PyObject * obj0 = 0 ;
19956 char *kwnames[] = {
19957 (char *) "win", NULL
19958 };
19959
19960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19961 if (obj0) {
19962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19963 if (SWIG_arg_fail(1)) SWIG_fail;
19964 }
19965 {
19966 PyThreadState* __tstate = wxPyBeginAllowThreads();
19967 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19968
19969 wxPyEndAllowThreads(__tstate);
19970 if (PyErr_Occurred()) SWIG_fail;
19971 }
19972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19973 return resultobj;
19974 fail:
19975 return NULL;
19976 }
19977
19978
19979 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19980 PyObject *resultobj;
19981 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19982 wxWindow *result;
19983 PyObject * obj0 = 0 ;
19984 char *kwnames[] = {
19985 (char *) "self", NULL
19986 };
19987
19988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19990 if (SWIG_arg_fail(1)) SWIG_fail;
19991 {
19992 PyThreadState* __tstate = wxPyBeginAllowThreads();
19993 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19994
19995 wxPyEndAllowThreads(__tstate);
19996 if (PyErr_Occurred()) SWIG_fail;
19997 }
19998 {
19999 resultobj = wxPyMake_wxObject(result, 0);
20000 }
20001 return resultobj;
20002 fail:
20003 return NULL;
20004 }
20005
20006
20007 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20008 PyObject *obj;
20009 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20010 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20011 Py_INCREF(obj);
20012 return Py_BuildValue((char *)"");
20013 }
20014 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20015 PyObject *resultobj;
20016 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20017 bool arg2 = (bool) true ;
20018 int arg3 = (int) 0 ;
20019 wxActivateEvent *result;
20020 PyObject * obj0 = 0 ;
20021 PyObject * obj1 = 0 ;
20022 PyObject * obj2 = 0 ;
20023 char *kwnames[] = {
20024 (char *) "type",(char *) "active",(char *) "Id", NULL
20025 };
20026
20027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20028 if (obj0) {
20029 {
20030 arg1 = (wxEventType)(SWIG_As_int(obj0));
20031 if (SWIG_arg_fail(1)) SWIG_fail;
20032 }
20033 }
20034 if (obj1) {
20035 {
20036 arg2 = (bool)(SWIG_As_bool(obj1));
20037 if (SWIG_arg_fail(2)) SWIG_fail;
20038 }
20039 }
20040 if (obj2) {
20041 {
20042 arg3 = (int)(SWIG_As_int(obj2));
20043 if (SWIG_arg_fail(3)) SWIG_fail;
20044 }
20045 }
20046 {
20047 PyThreadState* __tstate = wxPyBeginAllowThreads();
20048 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20049
20050 wxPyEndAllowThreads(__tstate);
20051 if (PyErr_Occurred()) SWIG_fail;
20052 }
20053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20054 return resultobj;
20055 fail:
20056 return NULL;
20057 }
20058
20059
20060 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20061 PyObject *resultobj;
20062 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20063 bool result;
20064 PyObject * obj0 = 0 ;
20065 char *kwnames[] = {
20066 (char *) "self", NULL
20067 };
20068
20069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20071 if (SWIG_arg_fail(1)) SWIG_fail;
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20075
20076 wxPyEndAllowThreads(__tstate);
20077 if (PyErr_Occurred()) SWIG_fail;
20078 }
20079 {
20080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20081 }
20082 return resultobj;
20083 fail:
20084 return NULL;
20085 }
20086
20087
20088 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20089 PyObject *obj;
20090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20091 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20092 Py_INCREF(obj);
20093 return Py_BuildValue((char *)"");
20094 }
20095 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20096 PyObject *resultobj;
20097 int arg1 = (int) 0 ;
20098 wxInitDialogEvent *result;
20099 PyObject * obj0 = 0 ;
20100 char *kwnames[] = {
20101 (char *) "Id", NULL
20102 };
20103
20104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20105 if (obj0) {
20106 {
20107 arg1 = (int)(SWIG_As_int(obj0));
20108 if (SWIG_arg_fail(1)) SWIG_fail;
20109 }
20110 }
20111 {
20112 PyThreadState* __tstate = wxPyBeginAllowThreads();
20113 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20114
20115 wxPyEndAllowThreads(__tstate);
20116 if (PyErr_Occurred()) SWIG_fail;
20117 }
20118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20119 return resultobj;
20120 fail:
20121 return NULL;
20122 }
20123
20124
20125 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20126 PyObject *obj;
20127 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20128 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20129 Py_INCREF(obj);
20130 return Py_BuildValue((char *)"");
20131 }
20132 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj;
20134 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20135 int arg2 = (int) 0 ;
20136 wxMenu *arg3 = (wxMenu *) NULL ;
20137 wxMenuEvent *result;
20138 PyObject * obj0 = 0 ;
20139 PyObject * obj1 = 0 ;
20140 PyObject * obj2 = 0 ;
20141 char *kwnames[] = {
20142 (char *) "type",(char *) "winid",(char *) "menu", NULL
20143 };
20144
20145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20146 if (obj0) {
20147 {
20148 arg1 = (wxEventType)(SWIG_As_int(obj0));
20149 if (SWIG_arg_fail(1)) SWIG_fail;
20150 }
20151 }
20152 if (obj1) {
20153 {
20154 arg2 = (int)(SWIG_As_int(obj1));
20155 if (SWIG_arg_fail(2)) SWIG_fail;
20156 }
20157 }
20158 if (obj2) {
20159 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20160 if (SWIG_arg_fail(3)) SWIG_fail;
20161 }
20162 {
20163 PyThreadState* __tstate = wxPyBeginAllowThreads();
20164 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20165
20166 wxPyEndAllowThreads(__tstate);
20167 if (PyErr_Occurred()) SWIG_fail;
20168 }
20169 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20177 PyObject *resultobj;
20178 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20179 int result;
20180 PyObject * obj0 = 0 ;
20181 char *kwnames[] = {
20182 (char *) "self", NULL
20183 };
20184
20185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20187 if (SWIG_arg_fail(1)) SWIG_fail;
20188 {
20189 PyThreadState* __tstate = wxPyBeginAllowThreads();
20190 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20191
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 {
20196 resultobj = SWIG_From_int((int)(result));
20197 }
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20205 PyObject *resultobj;
20206 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20207 bool result;
20208 PyObject * obj0 = 0 ;
20209 char *kwnames[] = {
20210 (char *) "self", NULL
20211 };
20212
20213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20215 if (SWIG_arg_fail(1)) SWIG_fail;
20216 {
20217 PyThreadState* __tstate = wxPyBeginAllowThreads();
20218 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20219
20220 wxPyEndAllowThreads(__tstate);
20221 if (PyErr_Occurred()) SWIG_fail;
20222 }
20223 {
20224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20225 }
20226 return resultobj;
20227 fail:
20228 return NULL;
20229 }
20230
20231
20232 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20233 PyObject *resultobj;
20234 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20235 wxMenu *result;
20236 PyObject * obj0 = 0 ;
20237 char *kwnames[] = {
20238 (char *) "self", NULL
20239 };
20240
20241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20243 if (SWIG_arg_fail(1)) SWIG_fail;
20244 {
20245 PyThreadState* __tstate = wxPyBeginAllowThreads();
20246 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20247
20248 wxPyEndAllowThreads(__tstate);
20249 if (PyErr_Occurred()) SWIG_fail;
20250 }
20251 {
20252 resultobj = wxPyMake_wxObject(result, 0);
20253 }
20254 return resultobj;
20255 fail:
20256 return NULL;
20257 }
20258
20259
20260 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20261 PyObject *obj;
20262 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20263 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20264 Py_INCREF(obj);
20265 return Py_BuildValue((char *)"");
20266 }
20267 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20268 PyObject *resultobj;
20269 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20270 int arg2 = (int) 0 ;
20271 wxCloseEvent *result;
20272 PyObject * obj0 = 0 ;
20273 PyObject * obj1 = 0 ;
20274 char *kwnames[] = {
20275 (char *) "type",(char *) "winid", NULL
20276 };
20277
20278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20279 if (obj0) {
20280 {
20281 arg1 = (wxEventType)(SWIG_As_int(obj0));
20282 if (SWIG_arg_fail(1)) SWIG_fail;
20283 }
20284 }
20285 if (obj1) {
20286 {
20287 arg2 = (int)(SWIG_As_int(obj1));
20288 if (SWIG_arg_fail(2)) SWIG_fail;
20289 }
20290 }
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20294
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20299 return resultobj;
20300 fail:
20301 return NULL;
20302 }
20303
20304
20305 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20306 PyObject *resultobj;
20307 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20308 bool arg2 ;
20309 PyObject * obj0 = 0 ;
20310 PyObject * obj1 = 0 ;
20311 char *kwnames[] = {
20312 (char *) "self",(char *) "logOff", NULL
20313 };
20314
20315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20317 if (SWIG_arg_fail(1)) SWIG_fail;
20318 {
20319 arg2 = (bool)(SWIG_As_bool(obj1));
20320 if (SWIG_arg_fail(2)) SWIG_fail;
20321 }
20322 {
20323 PyThreadState* __tstate = wxPyBeginAllowThreads();
20324 (arg1)->SetLoggingOff(arg2);
20325
20326 wxPyEndAllowThreads(__tstate);
20327 if (PyErr_Occurred()) SWIG_fail;
20328 }
20329 Py_INCREF(Py_None); resultobj = Py_None;
20330 return resultobj;
20331 fail:
20332 return NULL;
20333 }
20334
20335
20336 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20337 PyObject *resultobj;
20338 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20339 bool result;
20340 PyObject * obj0 = 0 ;
20341 char *kwnames[] = {
20342 (char *) "self", NULL
20343 };
20344
20345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20347 if (SWIG_arg_fail(1)) SWIG_fail;
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20351
20352 wxPyEndAllowThreads(__tstate);
20353 if (PyErr_Occurred()) SWIG_fail;
20354 }
20355 {
20356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20357 }
20358 return resultobj;
20359 fail:
20360 return NULL;
20361 }
20362
20363
20364 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20365 PyObject *resultobj;
20366 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20367 bool arg2 = (bool) true ;
20368 PyObject * obj0 = 0 ;
20369 PyObject * obj1 = 0 ;
20370 char *kwnames[] = {
20371 (char *) "self",(char *) "veto", NULL
20372 };
20373
20374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20376 if (SWIG_arg_fail(1)) SWIG_fail;
20377 if (obj1) {
20378 {
20379 arg2 = (bool)(SWIG_As_bool(obj1));
20380 if (SWIG_arg_fail(2)) SWIG_fail;
20381 }
20382 }
20383 {
20384 PyThreadState* __tstate = wxPyBeginAllowThreads();
20385 (arg1)->Veto(arg2);
20386
20387 wxPyEndAllowThreads(__tstate);
20388 if (PyErr_Occurred()) SWIG_fail;
20389 }
20390 Py_INCREF(Py_None); resultobj = Py_None;
20391 return resultobj;
20392 fail:
20393 return NULL;
20394 }
20395
20396
20397 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20398 PyObject *resultobj;
20399 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20400 bool result;
20401 PyObject * obj0 = 0 ;
20402 char *kwnames[] = {
20403 (char *) "self", NULL
20404 };
20405
20406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20408 if (SWIG_arg_fail(1)) SWIG_fail;
20409 {
20410 PyThreadState* __tstate = wxPyBeginAllowThreads();
20411 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20412
20413 wxPyEndAllowThreads(__tstate);
20414 if (PyErr_Occurred()) SWIG_fail;
20415 }
20416 {
20417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20418 }
20419 return resultobj;
20420 fail:
20421 return NULL;
20422 }
20423
20424
20425 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20426 PyObject *resultobj;
20427 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20428 bool arg2 ;
20429 PyObject * obj0 = 0 ;
20430 PyObject * obj1 = 0 ;
20431 char *kwnames[] = {
20432 (char *) "self",(char *) "canVeto", NULL
20433 };
20434
20435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20437 if (SWIG_arg_fail(1)) SWIG_fail;
20438 {
20439 arg2 = (bool)(SWIG_As_bool(obj1));
20440 if (SWIG_arg_fail(2)) SWIG_fail;
20441 }
20442 {
20443 PyThreadState* __tstate = wxPyBeginAllowThreads();
20444 (arg1)->SetCanVeto(arg2);
20445
20446 wxPyEndAllowThreads(__tstate);
20447 if (PyErr_Occurred()) SWIG_fail;
20448 }
20449 Py_INCREF(Py_None); resultobj = Py_None;
20450 return resultobj;
20451 fail:
20452 return NULL;
20453 }
20454
20455
20456 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20457 PyObject *resultobj;
20458 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20459 bool result;
20460 PyObject * obj0 = 0 ;
20461 char *kwnames[] = {
20462 (char *) "self", NULL
20463 };
20464
20465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20467 if (SWIG_arg_fail(1)) SWIG_fail;
20468 {
20469 PyThreadState* __tstate = wxPyBeginAllowThreads();
20470 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20471
20472 wxPyEndAllowThreads(__tstate);
20473 if (PyErr_Occurred()) SWIG_fail;
20474 }
20475 {
20476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20477 }
20478 return resultobj;
20479 fail:
20480 return NULL;
20481 }
20482
20483
20484 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20485 PyObject *obj;
20486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20487 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20488 Py_INCREF(obj);
20489 return Py_BuildValue((char *)"");
20490 }
20491 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20492 PyObject *resultobj;
20493 int arg1 = (int) 0 ;
20494 bool arg2 = (bool) false ;
20495 wxShowEvent *result;
20496 PyObject * obj0 = 0 ;
20497 PyObject * obj1 = 0 ;
20498 char *kwnames[] = {
20499 (char *) "winid",(char *) "show", NULL
20500 };
20501
20502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20503 if (obj0) {
20504 {
20505 arg1 = (int)(SWIG_As_int(obj0));
20506 if (SWIG_arg_fail(1)) SWIG_fail;
20507 }
20508 }
20509 if (obj1) {
20510 {
20511 arg2 = (bool)(SWIG_As_bool(obj1));
20512 if (SWIG_arg_fail(2)) SWIG_fail;
20513 }
20514 }
20515 {
20516 PyThreadState* __tstate = wxPyBeginAllowThreads();
20517 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20518
20519 wxPyEndAllowThreads(__tstate);
20520 if (PyErr_Occurred()) SWIG_fail;
20521 }
20522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20523 return resultobj;
20524 fail:
20525 return NULL;
20526 }
20527
20528
20529 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20530 PyObject *resultobj;
20531 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20532 bool arg2 ;
20533 PyObject * obj0 = 0 ;
20534 PyObject * obj1 = 0 ;
20535 char *kwnames[] = {
20536 (char *) "self",(char *) "show", NULL
20537 };
20538
20539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20541 if (SWIG_arg_fail(1)) SWIG_fail;
20542 {
20543 arg2 = (bool)(SWIG_As_bool(obj1));
20544 if (SWIG_arg_fail(2)) SWIG_fail;
20545 }
20546 {
20547 PyThreadState* __tstate = wxPyBeginAllowThreads();
20548 (arg1)->SetShow(arg2);
20549
20550 wxPyEndAllowThreads(__tstate);
20551 if (PyErr_Occurred()) SWIG_fail;
20552 }
20553 Py_INCREF(Py_None); resultobj = Py_None;
20554 return resultobj;
20555 fail:
20556 return NULL;
20557 }
20558
20559
20560 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20561 PyObject *resultobj;
20562 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20563 bool result;
20564 PyObject * obj0 = 0 ;
20565 char *kwnames[] = {
20566 (char *) "self", NULL
20567 };
20568
20569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20571 if (SWIG_arg_fail(1)) SWIG_fail;
20572 {
20573 PyThreadState* __tstate = wxPyBeginAllowThreads();
20574 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20575
20576 wxPyEndAllowThreads(__tstate);
20577 if (PyErr_Occurred()) SWIG_fail;
20578 }
20579 {
20580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20581 }
20582 return resultobj;
20583 fail:
20584 return NULL;
20585 }
20586
20587
20588 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20589 PyObject *obj;
20590 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20591 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20592 Py_INCREF(obj);
20593 return Py_BuildValue((char *)"");
20594 }
20595 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20596 PyObject *resultobj;
20597 int arg1 = (int) 0 ;
20598 bool arg2 = (bool) true ;
20599 wxIconizeEvent *result;
20600 PyObject * obj0 = 0 ;
20601 PyObject * obj1 = 0 ;
20602 char *kwnames[] = {
20603 (char *) "id",(char *) "iconized", NULL
20604 };
20605
20606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20607 if (obj0) {
20608 {
20609 arg1 = (int)(SWIG_As_int(obj0));
20610 if (SWIG_arg_fail(1)) SWIG_fail;
20611 }
20612 }
20613 if (obj1) {
20614 {
20615 arg2 = (bool)(SWIG_As_bool(obj1));
20616 if (SWIG_arg_fail(2)) SWIG_fail;
20617 }
20618 }
20619 {
20620 PyThreadState* __tstate = wxPyBeginAllowThreads();
20621 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20622
20623 wxPyEndAllowThreads(__tstate);
20624 if (PyErr_Occurred()) SWIG_fail;
20625 }
20626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20627 return resultobj;
20628 fail:
20629 return NULL;
20630 }
20631
20632
20633 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20634 PyObject *resultobj;
20635 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20636 bool result;
20637 PyObject * obj0 = 0 ;
20638 char *kwnames[] = {
20639 (char *) "self", NULL
20640 };
20641
20642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20644 if (SWIG_arg_fail(1)) SWIG_fail;
20645 {
20646 PyThreadState* __tstate = wxPyBeginAllowThreads();
20647 result = (bool)(arg1)->Iconized();
20648
20649 wxPyEndAllowThreads(__tstate);
20650 if (PyErr_Occurred()) SWIG_fail;
20651 }
20652 {
20653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20654 }
20655 return resultobj;
20656 fail:
20657 return NULL;
20658 }
20659
20660
20661 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20662 PyObject *obj;
20663 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20664 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20665 Py_INCREF(obj);
20666 return Py_BuildValue((char *)"");
20667 }
20668 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20669 PyObject *resultobj;
20670 int arg1 = (int) 0 ;
20671 wxMaximizeEvent *result;
20672 PyObject * obj0 = 0 ;
20673 char *kwnames[] = {
20674 (char *) "id", NULL
20675 };
20676
20677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20678 if (obj0) {
20679 {
20680 arg1 = (int)(SWIG_As_int(obj0));
20681 if (SWIG_arg_fail(1)) SWIG_fail;
20682 }
20683 }
20684 {
20685 PyThreadState* __tstate = wxPyBeginAllowThreads();
20686 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20687
20688 wxPyEndAllowThreads(__tstate);
20689 if (PyErr_Occurred()) SWIG_fail;
20690 }
20691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20692 return resultobj;
20693 fail:
20694 return NULL;
20695 }
20696
20697
20698 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20699 PyObject *obj;
20700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20701 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20702 Py_INCREF(obj);
20703 return Py_BuildValue((char *)"");
20704 }
20705 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20706 PyObject *resultobj;
20707 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20708 wxPoint result;
20709 PyObject * obj0 = 0 ;
20710 char *kwnames[] = {
20711 (char *) "self", NULL
20712 };
20713
20714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20716 if (SWIG_arg_fail(1)) SWIG_fail;
20717 {
20718 PyThreadState* __tstate = wxPyBeginAllowThreads();
20719 result = (arg1)->GetPosition();
20720
20721 wxPyEndAllowThreads(__tstate);
20722 if (PyErr_Occurred()) SWIG_fail;
20723 }
20724 {
20725 wxPoint * resultptr;
20726 resultptr = new wxPoint((wxPoint &)(result));
20727 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20728 }
20729 return resultobj;
20730 fail:
20731 return NULL;
20732 }
20733
20734
20735 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20736 PyObject *resultobj;
20737 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20738 int result;
20739 PyObject * obj0 = 0 ;
20740 char *kwnames[] = {
20741 (char *) "self", NULL
20742 };
20743
20744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20746 if (SWIG_arg_fail(1)) SWIG_fail;
20747 {
20748 PyThreadState* __tstate = wxPyBeginAllowThreads();
20749 result = (int)(arg1)->GetNumberOfFiles();
20750
20751 wxPyEndAllowThreads(__tstate);
20752 if (PyErr_Occurred()) SWIG_fail;
20753 }
20754 {
20755 resultobj = SWIG_From_int((int)(result));
20756 }
20757 return resultobj;
20758 fail:
20759 return NULL;
20760 }
20761
20762
20763 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20764 PyObject *resultobj;
20765 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20766 PyObject *result;
20767 PyObject * obj0 = 0 ;
20768 char *kwnames[] = {
20769 (char *) "self", NULL
20770 };
20771
20772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20774 if (SWIG_arg_fail(1)) SWIG_fail;
20775 {
20776 PyThreadState* __tstate = wxPyBeginAllowThreads();
20777 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20778
20779 wxPyEndAllowThreads(__tstate);
20780 if (PyErr_Occurred()) SWIG_fail;
20781 }
20782 resultobj = result;
20783 return resultobj;
20784 fail:
20785 return NULL;
20786 }
20787
20788
20789 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20790 PyObject *obj;
20791 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20792 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20793 Py_INCREF(obj);
20794 return Py_BuildValue((char *)"");
20795 }
20796 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20797 PyObject *resultobj;
20798 int arg1 = (int) 0 ;
20799 wxUpdateUIEvent *result;
20800 PyObject * obj0 = 0 ;
20801 char *kwnames[] = {
20802 (char *) "commandId", NULL
20803 };
20804
20805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20806 if (obj0) {
20807 {
20808 arg1 = (int)(SWIG_As_int(obj0));
20809 if (SWIG_arg_fail(1)) SWIG_fail;
20810 }
20811 }
20812 {
20813 PyThreadState* __tstate = wxPyBeginAllowThreads();
20814 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20815
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20827 PyObject *resultobj;
20828 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20829 bool result;
20830 PyObject * obj0 = 0 ;
20831 char *kwnames[] = {
20832 (char *) "self", NULL
20833 };
20834
20835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20837 if (SWIG_arg_fail(1)) SWIG_fail;
20838 {
20839 PyThreadState* __tstate = wxPyBeginAllowThreads();
20840 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20841
20842 wxPyEndAllowThreads(__tstate);
20843 if (PyErr_Occurred()) SWIG_fail;
20844 }
20845 {
20846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20847 }
20848 return resultobj;
20849 fail:
20850 return NULL;
20851 }
20852
20853
20854 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20855 PyObject *resultobj;
20856 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20857 bool result;
20858 PyObject * obj0 = 0 ;
20859 char *kwnames[] = {
20860 (char *) "self", NULL
20861 };
20862
20863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20865 if (SWIG_arg_fail(1)) SWIG_fail;
20866 {
20867 PyThreadState* __tstate = wxPyBeginAllowThreads();
20868 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20869
20870 wxPyEndAllowThreads(__tstate);
20871 if (PyErr_Occurred()) SWIG_fail;
20872 }
20873 {
20874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20875 }
20876 return resultobj;
20877 fail:
20878 return NULL;
20879 }
20880
20881
20882 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20883 PyObject *resultobj;
20884 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20885 wxString result;
20886 PyObject * obj0 = 0 ;
20887 char *kwnames[] = {
20888 (char *) "self", NULL
20889 };
20890
20891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20893 if (SWIG_arg_fail(1)) SWIG_fail;
20894 {
20895 PyThreadState* __tstate = wxPyBeginAllowThreads();
20896 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20897
20898 wxPyEndAllowThreads(__tstate);
20899 if (PyErr_Occurred()) SWIG_fail;
20900 }
20901 {
20902 #if wxUSE_UNICODE
20903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20904 #else
20905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20906 #endif
20907 }
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20915 PyObject *resultobj;
20916 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20917 bool result;
20918 PyObject * obj0 = 0 ;
20919 char *kwnames[] = {
20920 (char *) "self", NULL
20921 };
20922
20923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20925 if (SWIG_arg_fail(1)) SWIG_fail;
20926 {
20927 PyThreadState* __tstate = wxPyBeginAllowThreads();
20928 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20929
20930 wxPyEndAllowThreads(__tstate);
20931 if (PyErr_Occurred()) SWIG_fail;
20932 }
20933 {
20934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20935 }
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20943 PyObject *resultobj;
20944 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20945 bool result;
20946 PyObject * obj0 = 0 ;
20947 char *kwnames[] = {
20948 (char *) "self", NULL
20949 };
20950
20951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20953 if (SWIG_arg_fail(1)) SWIG_fail;
20954 {
20955 PyThreadState* __tstate = wxPyBeginAllowThreads();
20956 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20957
20958 wxPyEndAllowThreads(__tstate);
20959 if (PyErr_Occurred()) SWIG_fail;
20960 }
20961 {
20962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20963 }
20964 return resultobj;
20965 fail:
20966 return NULL;
20967 }
20968
20969
20970 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20971 PyObject *resultobj;
20972 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20973 bool result;
20974 PyObject * obj0 = 0 ;
20975 char *kwnames[] = {
20976 (char *) "self", NULL
20977 };
20978
20979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20981 if (SWIG_arg_fail(1)) SWIG_fail;
20982 {
20983 PyThreadState* __tstate = wxPyBeginAllowThreads();
20984 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20985
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 {
20990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20991 }
20992 return resultobj;
20993 fail:
20994 return NULL;
20995 }
20996
20997
20998 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20999 PyObject *resultobj;
21000 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21001 bool arg2 ;
21002 PyObject * obj0 = 0 ;
21003 PyObject * obj1 = 0 ;
21004 char *kwnames[] = {
21005 (char *) "self",(char *) "check", NULL
21006 };
21007
21008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21010 if (SWIG_arg_fail(1)) SWIG_fail;
21011 {
21012 arg2 = (bool)(SWIG_As_bool(obj1));
21013 if (SWIG_arg_fail(2)) SWIG_fail;
21014 }
21015 {
21016 PyThreadState* __tstate = wxPyBeginAllowThreads();
21017 (arg1)->Check(arg2);
21018
21019 wxPyEndAllowThreads(__tstate);
21020 if (PyErr_Occurred()) SWIG_fail;
21021 }
21022 Py_INCREF(Py_None); resultobj = Py_None;
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21030 PyObject *resultobj;
21031 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21032 bool arg2 ;
21033 PyObject * obj0 = 0 ;
21034 PyObject * obj1 = 0 ;
21035 char *kwnames[] = {
21036 (char *) "self",(char *) "enable", NULL
21037 };
21038
21039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21041 if (SWIG_arg_fail(1)) SWIG_fail;
21042 {
21043 arg2 = (bool)(SWIG_As_bool(obj1));
21044 if (SWIG_arg_fail(2)) SWIG_fail;
21045 }
21046 {
21047 PyThreadState* __tstate = wxPyBeginAllowThreads();
21048 (arg1)->Enable(arg2);
21049
21050 wxPyEndAllowThreads(__tstate);
21051 if (PyErr_Occurred()) SWIG_fail;
21052 }
21053 Py_INCREF(Py_None); resultobj = Py_None;
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21061 PyObject *resultobj;
21062 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21063 wxString *arg2 = 0 ;
21064 bool temp2 = false ;
21065 PyObject * obj0 = 0 ;
21066 PyObject * obj1 = 0 ;
21067 char *kwnames[] = {
21068 (char *) "self",(char *) "text", NULL
21069 };
21070
21071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21073 if (SWIG_arg_fail(1)) SWIG_fail;
21074 {
21075 arg2 = wxString_in_helper(obj1);
21076 if (arg2 == NULL) SWIG_fail;
21077 temp2 = true;
21078 }
21079 {
21080 PyThreadState* __tstate = wxPyBeginAllowThreads();
21081 (arg1)->SetText((wxString const &)*arg2);
21082
21083 wxPyEndAllowThreads(__tstate);
21084 if (PyErr_Occurred()) SWIG_fail;
21085 }
21086 Py_INCREF(Py_None); resultobj = Py_None;
21087 {
21088 if (temp2)
21089 delete arg2;
21090 }
21091 return resultobj;
21092 fail:
21093 {
21094 if (temp2)
21095 delete arg2;
21096 }
21097 return NULL;
21098 }
21099
21100
21101 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21102 PyObject *resultobj;
21103 long arg1 ;
21104 PyObject * obj0 = 0 ;
21105 char *kwnames[] = {
21106 (char *) "updateInterval", NULL
21107 };
21108
21109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21110 {
21111 arg1 = (long)(SWIG_As_long(obj0));
21112 if (SWIG_arg_fail(1)) SWIG_fail;
21113 }
21114 {
21115 PyThreadState* __tstate = wxPyBeginAllowThreads();
21116 wxUpdateUIEvent::SetUpdateInterval(arg1);
21117
21118 wxPyEndAllowThreads(__tstate);
21119 if (PyErr_Occurred()) SWIG_fail;
21120 }
21121 Py_INCREF(Py_None); resultobj = Py_None;
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21129 PyObject *resultobj;
21130 long result;
21131 char *kwnames[] = {
21132 NULL
21133 };
21134
21135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21136 {
21137 PyThreadState* __tstate = wxPyBeginAllowThreads();
21138 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21139
21140 wxPyEndAllowThreads(__tstate);
21141 if (PyErr_Occurred()) SWIG_fail;
21142 }
21143 {
21144 resultobj = SWIG_From_long((long)(result));
21145 }
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21153 PyObject *resultobj;
21154 wxWindow *arg1 = (wxWindow *) 0 ;
21155 bool result;
21156 PyObject * obj0 = 0 ;
21157 char *kwnames[] = {
21158 (char *) "win", NULL
21159 };
21160
21161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21163 if (SWIG_arg_fail(1)) SWIG_fail;
21164 {
21165 PyThreadState* __tstate = wxPyBeginAllowThreads();
21166 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21167
21168 wxPyEndAllowThreads(__tstate);
21169 if (PyErr_Occurred()) SWIG_fail;
21170 }
21171 {
21172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21173 }
21174 return resultobj;
21175 fail:
21176 return NULL;
21177 }
21178
21179
21180 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21181 PyObject *resultobj;
21182 char *kwnames[] = {
21183 NULL
21184 };
21185
21186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 wxUpdateUIEvent::ResetUpdateTime();
21190
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 Py_INCREF(Py_None); resultobj = Py_None;
21195 return resultobj;
21196 fail:
21197 return NULL;
21198 }
21199
21200
21201 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21202 PyObject *resultobj;
21203 wxUpdateUIMode arg1 ;
21204 PyObject * obj0 = 0 ;
21205 char *kwnames[] = {
21206 (char *) "mode", NULL
21207 };
21208
21209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21210 {
21211 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21212 if (SWIG_arg_fail(1)) SWIG_fail;
21213 }
21214 {
21215 PyThreadState* __tstate = wxPyBeginAllowThreads();
21216 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21217
21218 wxPyEndAllowThreads(__tstate);
21219 if (PyErr_Occurred()) SWIG_fail;
21220 }
21221 Py_INCREF(Py_None); resultobj = Py_None;
21222 return resultobj;
21223 fail:
21224 return NULL;
21225 }
21226
21227
21228 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21229 PyObject *resultobj;
21230 wxUpdateUIMode result;
21231 char *kwnames[] = {
21232 NULL
21233 };
21234
21235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21236 {
21237 PyThreadState* __tstate = wxPyBeginAllowThreads();
21238 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21239
21240 wxPyEndAllowThreads(__tstate);
21241 if (PyErr_Occurred()) SWIG_fail;
21242 }
21243 resultobj = SWIG_From_int((result));
21244 return resultobj;
21245 fail:
21246 return NULL;
21247 }
21248
21249
21250 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21251 PyObject *obj;
21252 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21253 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21254 Py_INCREF(obj);
21255 return Py_BuildValue((char *)"");
21256 }
21257 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21258 PyObject *resultobj;
21259 wxSysColourChangedEvent *result;
21260 char *kwnames[] = {
21261 NULL
21262 };
21263
21264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21265 {
21266 PyThreadState* __tstate = wxPyBeginAllowThreads();
21267 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21268
21269 wxPyEndAllowThreads(__tstate);
21270 if (PyErr_Occurred()) SWIG_fail;
21271 }
21272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21273 return resultobj;
21274 fail:
21275 return NULL;
21276 }
21277
21278
21279 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21280 PyObject *obj;
21281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21282 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21283 Py_INCREF(obj);
21284 return Py_BuildValue((char *)"");
21285 }
21286 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21287 PyObject *resultobj;
21288 int arg1 = (int) 0 ;
21289 wxWindow *arg2 = (wxWindow *) NULL ;
21290 wxMouseCaptureChangedEvent *result;
21291 PyObject * obj0 = 0 ;
21292 PyObject * obj1 = 0 ;
21293 char *kwnames[] = {
21294 (char *) "winid",(char *) "gainedCapture", NULL
21295 };
21296
21297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21298 if (obj0) {
21299 {
21300 arg1 = (int)(SWIG_As_int(obj0));
21301 if (SWIG_arg_fail(1)) SWIG_fail;
21302 }
21303 }
21304 if (obj1) {
21305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21306 if (SWIG_arg_fail(2)) SWIG_fail;
21307 }
21308 {
21309 PyThreadState* __tstate = wxPyBeginAllowThreads();
21310 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21311
21312 wxPyEndAllowThreads(__tstate);
21313 if (PyErr_Occurred()) SWIG_fail;
21314 }
21315 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21316 return resultobj;
21317 fail:
21318 return NULL;
21319 }
21320
21321
21322 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21323 PyObject *resultobj;
21324 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21325 wxWindow *result;
21326 PyObject * obj0 = 0 ;
21327 char *kwnames[] = {
21328 (char *) "self", NULL
21329 };
21330
21331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21333 if (SWIG_arg_fail(1)) SWIG_fail;
21334 {
21335 PyThreadState* __tstate = wxPyBeginAllowThreads();
21336 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21337
21338 wxPyEndAllowThreads(__tstate);
21339 if (PyErr_Occurred()) SWIG_fail;
21340 }
21341 {
21342 resultobj = wxPyMake_wxObject(result, 0);
21343 }
21344 return resultobj;
21345 fail:
21346 return NULL;
21347 }
21348
21349
21350 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21351 PyObject *obj;
21352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21353 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21354 Py_INCREF(obj);
21355 return Py_BuildValue((char *)"");
21356 }
21357 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21358 PyObject *resultobj;
21359 wxDisplayChangedEvent *result;
21360 char *kwnames[] = {
21361 NULL
21362 };
21363
21364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21365 {
21366 PyThreadState* __tstate = wxPyBeginAllowThreads();
21367 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21368
21369 wxPyEndAllowThreads(__tstate);
21370 if (PyErr_Occurred()) SWIG_fail;
21371 }
21372 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21373 return resultobj;
21374 fail:
21375 return NULL;
21376 }
21377
21378
21379 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21380 PyObject *obj;
21381 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21382 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21383 Py_INCREF(obj);
21384 return Py_BuildValue((char *)"");
21385 }
21386 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21387 PyObject *resultobj;
21388 int arg1 = (int) 0 ;
21389 wxPaletteChangedEvent *result;
21390 PyObject * obj0 = 0 ;
21391 char *kwnames[] = {
21392 (char *) "id", NULL
21393 };
21394
21395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21396 if (obj0) {
21397 {
21398 arg1 = (int)(SWIG_As_int(obj0));
21399 if (SWIG_arg_fail(1)) SWIG_fail;
21400 }
21401 }
21402 {
21403 PyThreadState* __tstate = wxPyBeginAllowThreads();
21404 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21405
21406 wxPyEndAllowThreads(__tstate);
21407 if (PyErr_Occurred()) SWIG_fail;
21408 }
21409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21410 return resultobj;
21411 fail:
21412 return NULL;
21413 }
21414
21415
21416 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21417 PyObject *resultobj;
21418 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21419 wxWindow *arg2 = (wxWindow *) 0 ;
21420 PyObject * obj0 = 0 ;
21421 PyObject * obj1 = 0 ;
21422 char *kwnames[] = {
21423 (char *) "self",(char *) "win", NULL
21424 };
21425
21426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21428 if (SWIG_arg_fail(1)) SWIG_fail;
21429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21430 if (SWIG_arg_fail(2)) SWIG_fail;
21431 {
21432 PyThreadState* __tstate = wxPyBeginAllowThreads();
21433 (arg1)->SetChangedWindow(arg2);
21434
21435 wxPyEndAllowThreads(__tstate);
21436 if (PyErr_Occurred()) SWIG_fail;
21437 }
21438 Py_INCREF(Py_None); resultobj = Py_None;
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21446 PyObject *resultobj;
21447 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21448 wxWindow *result;
21449 PyObject * obj0 = 0 ;
21450 char *kwnames[] = {
21451 (char *) "self", NULL
21452 };
21453
21454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21456 if (SWIG_arg_fail(1)) SWIG_fail;
21457 {
21458 PyThreadState* __tstate = wxPyBeginAllowThreads();
21459 result = (wxWindow *)(arg1)->GetChangedWindow();
21460
21461 wxPyEndAllowThreads(__tstate);
21462 if (PyErr_Occurred()) SWIG_fail;
21463 }
21464 {
21465 resultobj = wxPyMake_wxObject(result, 0);
21466 }
21467 return resultobj;
21468 fail:
21469 return NULL;
21470 }
21471
21472
21473 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21474 PyObject *obj;
21475 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21476 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21477 Py_INCREF(obj);
21478 return Py_BuildValue((char *)"");
21479 }
21480 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21481 PyObject *resultobj;
21482 int arg1 = (int) 0 ;
21483 wxQueryNewPaletteEvent *result;
21484 PyObject * obj0 = 0 ;
21485 char *kwnames[] = {
21486 (char *) "winid", NULL
21487 };
21488
21489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21490 if (obj0) {
21491 {
21492 arg1 = (int)(SWIG_As_int(obj0));
21493 if (SWIG_arg_fail(1)) SWIG_fail;
21494 }
21495 }
21496 {
21497 PyThreadState* __tstate = wxPyBeginAllowThreads();
21498 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21499
21500 wxPyEndAllowThreads(__tstate);
21501 if (PyErr_Occurred()) SWIG_fail;
21502 }
21503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21504 return resultobj;
21505 fail:
21506 return NULL;
21507 }
21508
21509
21510 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21511 PyObject *resultobj;
21512 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21513 bool arg2 ;
21514 PyObject * obj0 = 0 ;
21515 PyObject * obj1 = 0 ;
21516 char *kwnames[] = {
21517 (char *) "self",(char *) "realized", NULL
21518 };
21519
21520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21522 if (SWIG_arg_fail(1)) SWIG_fail;
21523 {
21524 arg2 = (bool)(SWIG_As_bool(obj1));
21525 if (SWIG_arg_fail(2)) SWIG_fail;
21526 }
21527 {
21528 PyThreadState* __tstate = wxPyBeginAllowThreads();
21529 (arg1)->SetPaletteRealized(arg2);
21530
21531 wxPyEndAllowThreads(__tstate);
21532 if (PyErr_Occurred()) SWIG_fail;
21533 }
21534 Py_INCREF(Py_None); resultobj = Py_None;
21535 return resultobj;
21536 fail:
21537 return NULL;
21538 }
21539
21540
21541 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21542 PyObject *resultobj;
21543 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21544 bool result;
21545 PyObject * obj0 = 0 ;
21546 char *kwnames[] = {
21547 (char *) "self", NULL
21548 };
21549
21550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21552 if (SWIG_arg_fail(1)) SWIG_fail;
21553 {
21554 PyThreadState* __tstate = wxPyBeginAllowThreads();
21555 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21556
21557 wxPyEndAllowThreads(__tstate);
21558 if (PyErr_Occurred()) SWIG_fail;
21559 }
21560 {
21561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21562 }
21563 return resultobj;
21564 fail:
21565 return NULL;
21566 }
21567
21568
21569 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21570 PyObject *obj;
21571 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21572 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21573 Py_INCREF(obj);
21574 return Py_BuildValue((char *)"");
21575 }
21576 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21577 PyObject *resultobj;
21578 wxNavigationKeyEvent *result;
21579 char *kwnames[] = {
21580 NULL
21581 };
21582
21583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21584 {
21585 PyThreadState* __tstate = wxPyBeginAllowThreads();
21586 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21587
21588 wxPyEndAllowThreads(__tstate);
21589 if (PyErr_Occurred()) SWIG_fail;
21590 }
21591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21592 return resultobj;
21593 fail:
21594 return NULL;
21595 }
21596
21597
21598 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21599 PyObject *resultobj;
21600 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21601 bool result;
21602 PyObject * obj0 = 0 ;
21603 char *kwnames[] = {
21604 (char *) "self", NULL
21605 };
21606
21607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21609 if (SWIG_arg_fail(1)) SWIG_fail;
21610 {
21611 PyThreadState* __tstate = wxPyBeginAllowThreads();
21612 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21613
21614 wxPyEndAllowThreads(__tstate);
21615 if (PyErr_Occurred()) SWIG_fail;
21616 }
21617 {
21618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21619 }
21620 return resultobj;
21621 fail:
21622 return NULL;
21623 }
21624
21625
21626 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21627 PyObject *resultobj;
21628 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21629 bool arg2 ;
21630 PyObject * obj0 = 0 ;
21631 PyObject * obj1 = 0 ;
21632 char *kwnames[] = {
21633 (char *) "self",(char *) "forward", NULL
21634 };
21635
21636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21638 if (SWIG_arg_fail(1)) SWIG_fail;
21639 {
21640 arg2 = (bool)(SWIG_As_bool(obj1));
21641 if (SWIG_arg_fail(2)) SWIG_fail;
21642 }
21643 {
21644 PyThreadState* __tstate = wxPyBeginAllowThreads();
21645 (arg1)->SetDirection(arg2);
21646
21647 wxPyEndAllowThreads(__tstate);
21648 if (PyErr_Occurred()) SWIG_fail;
21649 }
21650 Py_INCREF(Py_None); resultobj = Py_None;
21651 return resultobj;
21652 fail:
21653 return NULL;
21654 }
21655
21656
21657 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21658 PyObject *resultobj;
21659 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21660 bool result;
21661 PyObject * obj0 = 0 ;
21662 char *kwnames[] = {
21663 (char *) "self", NULL
21664 };
21665
21666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21668 if (SWIG_arg_fail(1)) SWIG_fail;
21669 {
21670 PyThreadState* __tstate = wxPyBeginAllowThreads();
21671 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21672
21673 wxPyEndAllowThreads(__tstate);
21674 if (PyErr_Occurred()) SWIG_fail;
21675 }
21676 {
21677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21678 }
21679 return resultobj;
21680 fail:
21681 return NULL;
21682 }
21683
21684
21685 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21686 PyObject *resultobj;
21687 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21688 bool arg2 ;
21689 PyObject * obj0 = 0 ;
21690 PyObject * obj1 = 0 ;
21691 char *kwnames[] = {
21692 (char *) "self",(char *) "ischange", NULL
21693 };
21694
21695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21697 if (SWIG_arg_fail(1)) SWIG_fail;
21698 {
21699 arg2 = (bool)(SWIG_As_bool(obj1));
21700 if (SWIG_arg_fail(2)) SWIG_fail;
21701 }
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 (arg1)->SetWindowChange(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_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj;
21718 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 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:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21727 if (SWIG_arg_fail(1)) SWIG_fail;
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
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_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21745 PyObject *resultobj;
21746 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21747 bool arg2 ;
21748 PyObject * obj0 = 0 ;
21749 PyObject * obj1 = 0 ;
21750 char *kwnames[] = {
21751 (char *) "self",(char *) "bIs", NULL
21752 };
21753
21754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21756 if (SWIG_arg_fail(1)) SWIG_fail;
21757 {
21758 arg2 = (bool)(SWIG_As_bool(obj1));
21759 if (SWIG_arg_fail(2)) SWIG_fail;
21760 }
21761 {
21762 PyThreadState* __tstate = wxPyBeginAllowThreads();
21763 (arg1)->SetFromTab(arg2);
21764
21765 wxPyEndAllowThreads(__tstate);
21766 if (PyErr_Occurred()) SWIG_fail;
21767 }
21768 Py_INCREF(Py_None); resultobj = Py_None;
21769 return resultobj;
21770 fail:
21771 return NULL;
21772 }
21773
21774
21775 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21776 PyObject *resultobj;
21777 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21778 long arg2 ;
21779 PyObject * obj0 = 0 ;
21780 PyObject * obj1 = 0 ;
21781 char *kwnames[] = {
21782 (char *) "self",(char *) "flags", NULL
21783 };
21784
21785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21787 if (SWIG_arg_fail(1)) SWIG_fail;
21788 {
21789 arg2 = (long)(SWIG_As_long(obj1));
21790 if (SWIG_arg_fail(2)) SWIG_fail;
21791 }
21792 {
21793 PyThreadState* __tstate = wxPyBeginAllowThreads();
21794 (arg1)->SetFlags(arg2);
21795
21796 wxPyEndAllowThreads(__tstate);
21797 if (PyErr_Occurred()) SWIG_fail;
21798 }
21799 Py_INCREF(Py_None); resultobj = Py_None;
21800 return resultobj;
21801 fail:
21802 return NULL;
21803 }
21804
21805
21806 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21807 PyObject *resultobj;
21808 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21809 wxWindow *result;
21810 PyObject * obj0 = 0 ;
21811 char *kwnames[] = {
21812 (char *) "self", NULL
21813 };
21814
21815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21817 if (SWIG_arg_fail(1)) SWIG_fail;
21818 {
21819 PyThreadState* __tstate = wxPyBeginAllowThreads();
21820 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21821
21822 wxPyEndAllowThreads(__tstate);
21823 if (PyErr_Occurred()) SWIG_fail;
21824 }
21825 {
21826 resultobj = wxPyMake_wxObject(result, 0);
21827 }
21828 return resultobj;
21829 fail:
21830 return NULL;
21831 }
21832
21833
21834 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21835 PyObject *resultobj;
21836 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21837 wxWindow *arg2 = (wxWindow *) 0 ;
21838 PyObject * obj0 = 0 ;
21839 PyObject * obj1 = 0 ;
21840 char *kwnames[] = {
21841 (char *) "self",(char *) "win", NULL
21842 };
21843
21844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21846 if (SWIG_arg_fail(1)) SWIG_fail;
21847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21848 if (SWIG_arg_fail(2)) SWIG_fail;
21849 {
21850 PyThreadState* __tstate = wxPyBeginAllowThreads();
21851 (arg1)->SetCurrentFocus(arg2);
21852
21853 wxPyEndAllowThreads(__tstate);
21854 if (PyErr_Occurred()) SWIG_fail;
21855 }
21856 Py_INCREF(Py_None); resultobj = Py_None;
21857 return resultobj;
21858 fail:
21859 return NULL;
21860 }
21861
21862
21863 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21864 PyObject *obj;
21865 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21866 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21867 Py_INCREF(obj);
21868 return Py_BuildValue((char *)"");
21869 }
21870 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21871 PyObject *resultobj;
21872 wxWindow *arg1 = (wxWindow *) NULL ;
21873 wxWindowCreateEvent *result;
21874 PyObject * obj0 = 0 ;
21875 char *kwnames[] = {
21876 (char *) "win", NULL
21877 };
21878
21879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21880 if (obj0) {
21881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21882 if (SWIG_arg_fail(1)) SWIG_fail;
21883 }
21884 {
21885 PyThreadState* __tstate = wxPyBeginAllowThreads();
21886 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21887
21888 wxPyEndAllowThreads(__tstate);
21889 if (PyErr_Occurred()) SWIG_fail;
21890 }
21891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21892 return resultobj;
21893 fail:
21894 return NULL;
21895 }
21896
21897
21898 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21899 PyObject *resultobj;
21900 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21901 wxWindow *result;
21902 PyObject * obj0 = 0 ;
21903 char *kwnames[] = {
21904 (char *) "self", NULL
21905 };
21906
21907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21909 if (SWIG_arg_fail(1)) SWIG_fail;
21910 {
21911 PyThreadState* __tstate = wxPyBeginAllowThreads();
21912 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21913
21914 wxPyEndAllowThreads(__tstate);
21915 if (PyErr_Occurred()) SWIG_fail;
21916 }
21917 {
21918 resultobj = wxPyMake_wxObject(result, 0);
21919 }
21920 return resultobj;
21921 fail:
21922 return NULL;
21923 }
21924
21925
21926 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21927 PyObject *obj;
21928 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21929 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21930 Py_INCREF(obj);
21931 return Py_BuildValue((char *)"");
21932 }
21933 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21934 PyObject *resultobj;
21935 wxWindow *arg1 = (wxWindow *) NULL ;
21936 wxWindowDestroyEvent *result;
21937 PyObject * obj0 = 0 ;
21938 char *kwnames[] = {
21939 (char *) "win", NULL
21940 };
21941
21942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21943 if (obj0) {
21944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21945 if (SWIG_arg_fail(1)) SWIG_fail;
21946 }
21947 {
21948 PyThreadState* __tstate = wxPyBeginAllowThreads();
21949 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21950
21951 wxPyEndAllowThreads(__tstate);
21952 if (PyErr_Occurred()) SWIG_fail;
21953 }
21954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21955 return resultobj;
21956 fail:
21957 return NULL;
21958 }
21959
21960
21961 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21962 PyObject *resultobj;
21963 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21964 wxWindow *result;
21965 PyObject * obj0 = 0 ;
21966 char *kwnames[] = {
21967 (char *) "self", NULL
21968 };
21969
21970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21972 if (SWIG_arg_fail(1)) SWIG_fail;
21973 {
21974 PyThreadState* __tstate = wxPyBeginAllowThreads();
21975 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21976
21977 wxPyEndAllowThreads(__tstate);
21978 if (PyErr_Occurred()) SWIG_fail;
21979 }
21980 {
21981 resultobj = wxPyMake_wxObject(result, 0);
21982 }
21983 return resultobj;
21984 fail:
21985 return NULL;
21986 }
21987
21988
21989 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21990 PyObject *obj;
21991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21992 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21993 Py_INCREF(obj);
21994 return Py_BuildValue((char *)"");
21995 }
21996 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21997 PyObject *resultobj;
21998 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21999 int arg2 = (int) 0 ;
22000 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22001 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22002 wxContextMenuEvent *result;
22003 wxPoint temp3 ;
22004 PyObject * obj0 = 0 ;
22005 PyObject * obj1 = 0 ;
22006 PyObject * obj2 = 0 ;
22007 char *kwnames[] = {
22008 (char *) "type",(char *) "winid",(char *) "pt", NULL
22009 };
22010
22011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22012 if (obj0) {
22013 {
22014 arg1 = (wxEventType)(SWIG_As_int(obj0));
22015 if (SWIG_arg_fail(1)) SWIG_fail;
22016 }
22017 }
22018 if (obj1) {
22019 {
22020 arg2 = (int)(SWIG_As_int(obj1));
22021 if (SWIG_arg_fail(2)) SWIG_fail;
22022 }
22023 }
22024 if (obj2) {
22025 {
22026 arg3 = &temp3;
22027 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22028 }
22029 }
22030 {
22031 PyThreadState* __tstate = wxPyBeginAllowThreads();
22032 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22033
22034 wxPyEndAllowThreads(__tstate);
22035 if (PyErr_Occurred()) SWIG_fail;
22036 }
22037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22038 return resultobj;
22039 fail:
22040 return NULL;
22041 }
22042
22043
22044 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22045 PyObject *resultobj;
22046 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22047 wxPoint *result;
22048 PyObject * obj0 = 0 ;
22049 char *kwnames[] = {
22050 (char *) "self", NULL
22051 };
22052
22053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22055 if (SWIG_arg_fail(1)) SWIG_fail;
22056 {
22057 PyThreadState* __tstate = wxPyBeginAllowThreads();
22058 {
22059 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22060 result = (wxPoint *) &_result_ref;
22061 }
22062
22063 wxPyEndAllowThreads(__tstate);
22064 if (PyErr_Occurred()) SWIG_fail;
22065 }
22066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22067 return resultobj;
22068 fail:
22069 return NULL;
22070 }
22071
22072
22073 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22074 PyObject *resultobj;
22075 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22076 wxPoint *arg2 = 0 ;
22077 wxPoint temp2 ;
22078 PyObject * obj0 = 0 ;
22079 PyObject * obj1 = 0 ;
22080 char *kwnames[] = {
22081 (char *) "self",(char *) "pos", NULL
22082 };
22083
22084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22086 if (SWIG_arg_fail(1)) SWIG_fail;
22087 {
22088 arg2 = &temp2;
22089 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22090 }
22091 {
22092 PyThreadState* __tstate = wxPyBeginAllowThreads();
22093 (arg1)->SetPosition((wxPoint const &)*arg2);
22094
22095 wxPyEndAllowThreads(__tstate);
22096 if (PyErr_Occurred()) SWIG_fail;
22097 }
22098 Py_INCREF(Py_None); resultobj = Py_None;
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22106 PyObject *obj;
22107 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22108 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22109 Py_INCREF(obj);
22110 return Py_BuildValue((char *)"");
22111 }
22112 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22113 PyObject *resultobj;
22114 wxIdleEvent *result;
22115 char *kwnames[] = {
22116 NULL
22117 };
22118
22119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22120 {
22121 PyThreadState* __tstate = wxPyBeginAllowThreads();
22122 result = (wxIdleEvent *)new wxIdleEvent();
22123
22124 wxPyEndAllowThreads(__tstate);
22125 if (PyErr_Occurred()) SWIG_fail;
22126 }
22127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22128 return resultobj;
22129 fail:
22130 return NULL;
22131 }
22132
22133
22134 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22135 PyObject *resultobj;
22136 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22137 bool arg2 = (bool) true ;
22138 PyObject * obj0 = 0 ;
22139 PyObject * obj1 = 0 ;
22140 char *kwnames[] = {
22141 (char *) "self",(char *) "needMore", NULL
22142 };
22143
22144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22146 if (SWIG_arg_fail(1)) SWIG_fail;
22147 if (obj1) {
22148 {
22149 arg2 = (bool)(SWIG_As_bool(obj1));
22150 if (SWIG_arg_fail(2)) SWIG_fail;
22151 }
22152 }
22153 {
22154 PyThreadState* __tstate = wxPyBeginAllowThreads();
22155 (arg1)->RequestMore(arg2);
22156
22157 wxPyEndAllowThreads(__tstate);
22158 if (PyErr_Occurred()) SWIG_fail;
22159 }
22160 Py_INCREF(Py_None); resultobj = Py_None;
22161 return resultobj;
22162 fail:
22163 return NULL;
22164 }
22165
22166
22167 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22168 PyObject *resultobj;
22169 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22170 bool result;
22171 PyObject * obj0 = 0 ;
22172 char *kwnames[] = {
22173 (char *) "self", NULL
22174 };
22175
22176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22178 if (SWIG_arg_fail(1)) SWIG_fail;
22179 {
22180 PyThreadState* __tstate = wxPyBeginAllowThreads();
22181 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22182
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 {
22187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22188 }
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22196 PyObject *resultobj;
22197 wxIdleMode arg1 ;
22198 PyObject * obj0 = 0 ;
22199 char *kwnames[] = {
22200 (char *) "mode", NULL
22201 };
22202
22203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22204 {
22205 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22206 if (SWIG_arg_fail(1)) SWIG_fail;
22207 }
22208 {
22209 PyThreadState* __tstate = wxPyBeginAllowThreads();
22210 wxIdleEvent::SetMode((wxIdleMode )arg1);
22211
22212 wxPyEndAllowThreads(__tstate);
22213 if (PyErr_Occurred()) SWIG_fail;
22214 }
22215 Py_INCREF(Py_None); resultobj = Py_None;
22216 return resultobj;
22217 fail:
22218 return NULL;
22219 }
22220
22221
22222 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22223 PyObject *resultobj;
22224 wxIdleMode result;
22225 char *kwnames[] = {
22226 NULL
22227 };
22228
22229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22230 {
22231 PyThreadState* __tstate = wxPyBeginAllowThreads();
22232 result = (wxIdleMode)wxIdleEvent::GetMode();
22233
22234 wxPyEndAllowThreads(__tstate);
22235 if (PyErr_Occurred()) SWIG_fail;
22236 }
22237 resultobj = SWIG_From_int((result));
22238 return resultobj;
22239 fail:
22240 return NULL;
22241 }
22242
22243
22244 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22245 PyObject *resultobj;
22246 wxWindow *arg1 = (wxWindow *) 0 ;
22247 bool result;
22248 PyObject * obj0 = 0 ;
22249 char *kwnames[] = {
22250 (char *) "win", NULL
22251 };
22252
22253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22255 if (SWIG_arg_fail(1)) SWIG_fail;
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 result = (bool)wxIdleEvent::CanSend(arg1);
22259
22260 wxPyEndAllowThreads(__tstate);
22261 if (PyErr_Occurred()) SWIG_fail;
22262 }
22263 {
22264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22265 }
22266 return resultobj;
22267 fail:
22268 return NULL;
22269 }
22270
22271
22272 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22273 PyObject *obj;
22274 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22275 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22276 Py_INCREF(obj);
22277 return Py_BuildValue((char *)"");
22278 }
22279 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22280 PyObject *resultobj;
22281 int arg1 = (int) 0 ;
22282 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22283 wxPyEvent *result;
22284 PyObject * obj0 = 0 ;
22285 PyObject * obj1 = 0 ;
22286 char *kwnames[] = {
22287 (char *) "winid",(char *) "eventType", NULL
22288 };
22289
22290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22291 if (obj0) {
22292 {
22293 arg1 = (int)(SWIG_As_int(obj0));
22294 if (SWIG_arg_fail(1)) SWIG_fail;
22295 }
22296 }
22297 if (obj1) {
22298 {
22299 arg2 = (wxEventType)(SWIG_As_int(obj1));
22300 if (SWIG_arg_fail(2)) SWIG_fail;
22301 }
22302 }
22303 {
22304 PyThreadState* __tstate = wxPyBeginAllowThreads();
22305 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22306
22307 wxPyEndAllowThreads(__tstate);
22308 if (PyErr_Occurred()) SWIG_fail;
22309 }
22310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22311 return resultobj;
22312 fail:
22313 return NULL;
22314 }
22315
22316
22317 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22318 PyObject *resultobj;
22319 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22320 PyObject * obj0 = 0 ;
22321 char *kwnames[] = {
22322 (char *) "self", NULL
22323 };
22324
22325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22327 if (SWIG_arg_fail(1)) SWIG_fail;
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 delete arg1;
22331
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 Py_INCREF(Py_None); resultobj = Py_None;
22336 return resultobj;
22337 fail:
22338 return NULL;
22339 }
22340
22341
22342 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22343 PyObject *resultobj;
22344 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22345 PyObject *arg2 = (PyObject *) 0 ;
22346 PyObject * obj0 = 0 ;
22347 PyObject * obj1 = 0 ;
22348 char *kwnames[] = {
22349 (char *) "self",(char *) "self", NULL
22350 };
22351
22352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22354 if (SWIG_arg_fail(1)) SWIG_fail;
22355 arg2 = obj1;
22356 {
22357 PyThreadState* __tstate = wxPyBeginAllowThreads();
22358 (arg1)->SetSelf(arg2);
22359
22360 wxPyEndAllowThreads(__tstate);
22361 if (PyErr_Occurred()) SWIG_fail;
22362 }
22363 Py_INCREF(Py_None); resultobj = Py_None;
22364 return resultobj;
22365 fail:
22366 return NULL;
22367 }
22368
22369
22370 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22371 PyObject *resultobj;
22372 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22373 PyObject *result;
22374 PyObject * obj0 = 0 ;
22375 char *kwnames[] = {
22376 (char *) "self", NULL
22377 };
22378
22379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
22380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22381 if (SWIG_arg_fail(1)) SWIG_fail;
22382 {
22383 PyThreadState* __tstate = wxPyBeginAllowThreads();
22384 result = (PyObject *)(arg1)->GetSelf();
22385
22386 wxPyEndAllowThreads(__tstate);
22387 if (PyErr_Occurred()) SWIG_fail;
22388 }
22389 resultobj = result;
22390 return resultobj;
22391 fail:
22392 return NULL;
22393 }
22394
22395
22396 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22397 PyObject *obj;
22398 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22399 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22400 Py_INCREF(obj);
22401 return Py_BuildValue((char *)"");
22402 }
22403 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22404 PyObject *resultobj;
22405 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22406 int arg2 = (int) 0 ;
22407 wxPyCommandEvent *result;
22408 PyObject * obj0 = 0 ;
22409 PyObject * obj1 = 0 ;
22410 char *kwnames[] = {
22411 (char *) "eventType",(char *) "id", NULL
22412 };
22413
22414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22415 if (obj0) {
22416 {
22417 arg1 = (wxEventType)(SWIG_As_int(obj0));
22418 if (SWIG_arg_fail(1)) SWIG_fail;
22419 }
22420 }
22421 if (obj1) {
22422 {
22423 arg2 = (int)(SWIG_As_int(obj1));
22424 if (SWIG_arg_fail(2)) SWIG_fail;
22425 }
22426 }
22427 {
22428 PyThreadState* __tstate = wxPyBeginAllowThreads();
22429 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22430
22431 wxPyEndAllowThreads(__tstate);
22432 if (PyErr_Occurred()) SWIG_fail;
22433 }
22434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22435 return resultobj;
22436 fail:
22437 return NULL;
22438 }
22439
22440
22441 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22442 PyObject *resultobj;
22443 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22444 PyObject * obj0 = 0 ;
22445 char *kwnames[] = {
22446 (char *) "self", NULL
22447 };
22448
22449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22451 if (SWIG_arg_fail(1)) SWIG_fail;
22452 {
22453 PyThreadState* __tstate = wxPyBeginAllowThreads();
22454 delete arg1;
22455
22456 wxPyEndAllowThreads(__tstate);
22457 if (PyErr_Occurred()) SWIG_fail;
22458 }
22459 Py_INCREF(Py_None); resultobj = Py_None;
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22467 PyObject *resultobj;
22468 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22469 PyObject *arg2 = (PyObject *) 0 ;
22470 PyObject * obj0 = 0 ;
22471 PyObject * obj1 = 0 ;
22472 char *kwnames[] = {
22473 (char *) "self",(char *) "self", NULL
22474 };
22475
22476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22478 if (SWIG_arg_fail(1)) SWIG_fail;
22479 arg2 = obj1;
22480 {
22481 PyThreadState* __tstate = wxPyBeginAllowThreads();
22482 (arg1)->SetSelf(arg2);
22483
22484 wxPyEndAllowThreads(__tstate);
22485 if (PyErr_Occurred()) SWIG_fail;
22486 }
22487 Py_INCREF(Py_None); resultobj = Py_None;
22488 return resultobj;
22489 fail:
22490 return NULL;
22491 }
22492
22493
22494 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22495 PyObject *resultobj;
22496 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22497 PyObject *result;
22498 PyObject * obj0 = 0 ;
22499 char *kwnames[] = {
22500 (char *) "self", NULL
22501 };
22502
22503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
22504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22505 if (SWIG_arg_fail(1)) SWIG_fail;
22506 {
22507 PyThreadState* __tstate = wxPyBeginAllowThreads();
22508 result = (PyObject *)(arg1)->GetSelf();
22509
22510 wxPyEndAllowThreads(__tstate);
22511 if (PyErr_Occurred()) SWIG_fail;
22512 }
22513 resultobj = result;
22514 return resultobj;
22515 fail:
22516 return NULL;
22517 }
22518
22519
22520 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22521 PyObject *obj;
22522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22523 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22524 Py_INCREF(obj);
22525 return Py_BuildValue((char *)"");
22526 }
22527 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22528 PyObject *resultobj;
22529 wxWindow *arg1 = (wxWindow *) 0 ;
22530 wxDateTime *arg2 = 0 ;
22531 wxEventType arg3 ;
22532 wxDateEvent *result;
22533 PyObject * obj0 = 0 ;
22534 PyObject * obj1 = 0 ;
22535 PyObject * obj2 = 0 ;
22536 char *kwnames[] = {
22537 (char *) "win",(char *) "dt",(char *) "type", NULL
22538 };
22539
22540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22542 if (SWIG_arg_fail(1)) SWIG_fail;
22543 {
22544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22545 if (SWIG_arg_fail(2)) SWIG_fail;
22546 if (arg2 == NULL) {
22547 SWIG_null_ref("wxDateTime");
22548 }
22549 if (SWIG_arg_fail(2)) SWIG_fail;
22550 }
22551 {
22552 arg3 = (wxEventType)(SWIG_As_int(obj2));
22553 if (SWIG_arg_fail(3)) SWIG_fail;
22554 }
22555 {
22556 PyThreadState* __tstate = wxPyBeginAllowThreads();
22557 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22558
22559 wxPyEndAllowThreads(__tstate);
22560 if (PyErr_Occurred()) SWIG_fail;
22561 }
22562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22563 return resultobj;
22564 fail:
22565 return NULL;
22566 }
22567
22568
22569 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22570 PyObject *resultobj;
22571 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22572 wxDateTime *result;
22573 PyObject * obj0 = 0 ;
22574 char *kwnames[] = {
22575 (char *) "self", NULL
22576 };
22577
22578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22580 if (SWIG_arg_fail(1)) SWIG_fail;
22581 {
22582 PyThreadState* __tstate = wxPyBeginAllowThreads();
22583 {
22584 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22585 result = (wxDateTime *) &_result_ref;
22586 }
22587
22588 wxPyEndAllowThreads(__tstate);
22589 if (PyErr_Occurred()) SWIG_fail;
22590 }
22591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22592 return resultobj;
22593 fail:
22594 return NULL;
22595 }
22596
22597
22598 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22599 PyObject *resultobj;
22600 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22601 wxDateTime *arg2 = 0 ;
22602 PyObject * obj0 = 0 ;
22603 PyObject * obj1 = 0 ;
22604 char *kwnames[] = {
22605 (char *) "self",(char *) "date", NULL
22606 };
22607
22608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22610 if (SWIG_arg_fail(1)) SWIG_fail;
22611 {
22612 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22613 if (SWIG_arg_fail(2)) SWIG_fail;
22614 if (arg2 == NULL) {
22615 SWIG_null_ref("wxDateTime");
22616 }
22617 if (SWIG_arg_fail(2)) SWIG_fail;
22618 }
22619 {
22620 PyThreadState* __tstate = wxPyBeginAllowThreads();
22621 (arg1)->SetDate((wxDateTime const &)*arg2);
22622
22623 wxPyEndAllowThreads(__tstate);
22624 if (PyErr_Occurred()) SWIG_fail;
22625 }
22626 Py_INCREF(Py_None); resultobj = Py_None;
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22634 PyObject *obj;
22635 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22636 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22637 Py_INCREF(obj);
22638 return Py_BuildValue((char *)"");
22639 }
22640 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22641 PyObject *resultobj;
22642 wxPyApp *result;
22643 char *kwnames[] = {
22644 NULL
22645 };
22646
22647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22648 {
22649 PyThreadState* __tstate = wxPyBeginAllowThreads();
22650 result = (wxPyApp *)new_wxPyApp();
22651
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22663 PyObject *resultobj;
22664 wxPyApp *arg1 = (wxPyApp *) 0 ;
22665 PyObject * obj0 = 0 ;
22666 char *kwnames[] = {
22667 (char *) "self", NULL
22668 };
22669
22670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22672 if (SWIG_arg_fail(1)) SWIG_fail;
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 delete arg1;
22676
22677 wxPyEndAllowThreads(__tstate);
22678 if (PyErr_Occurred()) SWIG_fail;
22679 }
22680 Py_INCREF(Py_None); resultobj = Py_None;
22681 return resultobj;
22682 fail:
22683 return NULL;
22684 }
22685
22686
22687 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22688 PyObject *resultobj;
22689 wxPyApp *arg1 = (wxPyApp *) 0 ;
22690 PyObject *arg2 = (PyObject *) 0 ;
22691 PyObject *arg3 = (PyObject *) 0 ;
22692 bool arg4 ;
22693 PyObject * obj0 = 0 ;
22694 PyObject * obj1 = 0 ;
22695 PyObject * obj2 = 0 ;
22696 PyObject * obj3 = 0 ;
22697 char *kwnames[] = {
22698 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
22699 };
22700
22701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
22702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22703 if (SWIG_arg_fail(1)) SWIG_fail;
22704 arg2 = obj1;
22705 arg3 = obj2;
22706 {
22707 arg4 = (bool)(SWIG_As_bool(obj3));
22708 if (SWIG_arg_fail(4)) SWIG_fail;
22709 }
22710 {
22711 PyThreadState* __tstate = wxPyBeginAllowThreads();
22712 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
22713
22714 wxPyEndAllowThreads(__tstate);
22715 if (PyErr_Occurred()) SWIG_fail;
22716 }
22717 Py_INCREF(Py_None); resultobj = Py_None;
22718 return resultobj;
22719 fail:
22720 return NULL;
22721 }
22722
22723
22724 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22725 PyObject *resultobj;
22726 wxPyApp *arg1 = (wxPyApp *) 0 ;
22727 wxString result;
22728 PyObject * obj0 = 0 ;
22729 char *kwnames[] = {
22730 (char *) "self", NULL
22731 };
22732
22733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22735 if (SWIG_arg_fail(1)) SWIG_fail;
22736 {
22737 PyThreadState* __tstate = wxPyBeginAllowThreads();
22738 result = ((wxPyApp const *)arg1)->GetAppName();
22739
22740 wxPyEndAllowThreads(__tstate);
22741 if (PyErr_Occurred()) SWIG_fail;
22742 }
22743 {
22744 #if wxUSE_UNICODE
22745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22746 #else
22747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22748 #endif
22749 }
22750 return resultobj;
22751 fail:
22752 return NULL;
22753 }
22754
22755
22756 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22757 PyObject *resultobj;
22758 wxPyApp *arg1 = (wxPyApp *) 0 ;
22759 wxString *arg2 = 0 ;
22760 bool temp2 = false ;
22761 PyObject * obj0 = 0 ;
22762 PyObject * obj1 = 0 ;
22763 char *kwnames[] = {
22764 (char *) "self",(char *) "name", NULL
22765 };
22766
22767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22769 if (SWIG_arg_fail(1)) SWIG_fail;
22770 {
22771 arg2 = wxString_in_helper(obj1);
22772 if (arg2 == NULL) SWIG_fail;
22773 temp2 = true;
22774 }
22775 {
22776 PyThreadState* __tstate = wxPyBeginAllowThreads();
22777 (arg1)->SetAppName((wxString const &)*arg2);
22778
22779 wxPyEndAllowThreads(__tstate);
22780 if (PyErr_Occurred()) SWIG_fail;
22781 }
22782 Py_INCREF(Py_None); resultobj = Py_None;
22783 {
22784 if (temp2)
22785 delete arg2;
22786 }
22787 return resultobj;
22788 fail:
22789 {
22790 if (temp2)
22791 delete arg2;
22792 }
22793 return NULL;
22794 }
22795
22796
22797 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22798 PyObject *resultobj;
22799 wxPyApp *arg1 = (wxPyApp *) 0 ;
22800 wxString result;
22801 PyObject * obj0 = 0 ;
22802 char *kwnames[] = {
22803 (char *) "self", NULL
22804 };
22805
22806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22808 if (SWIG_arg_fail(1)) SWIG_fail;
22809 {
22810 PyThreadState* __tstate = wxPyBeginAllowThreads();
22811 result = ((wxPyApp const *)arg1)->GetClassName();
22812
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 {
22817 #if wxUSE_UNICODE
22818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22819 #else
22820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22821 #endif
22822 }
22823 return resultobj;
22824 fail:
22825 return NULL;
22826 }
22827
22828
22829 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22830 PyObject *resultobj;
22831 wxPyApp *arg1 = (wxPyApp *) 0 ;
22832 wxString *arg2 = 0 ;
22833 bool temp2 = false ;
22834 PyObject * obj0 = 0 ;
22835 PyObject * obj1 = 0 ;
22836 char *kwnames[] = {
22837 (char *) "self",(char *) "name", NULL
22838 };
22839
22840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22842 if (SWIG_arg_fail(1)) SWIG_fail;
22843 {
22844 arg2 = wxString_in_helper(obj1);
22845 if (arg2 == NULL) SWIG_fail;
22846 temp2 = true;
22847 }
22848 {
22849 PyThreadState* __tstate = wxPyBeginAllowThreads();
22850 (arg1)->SetClassName((wxString const &)*arg2);
22851
22852 wxPyEndAllowThreads(__tstate);
22853 if (PyErr_Occurred()) SWIG_fail;
22854 }
22855 Py_INCREF(Py_None); resultobj = Py_None;
22856 {
22857 if (temp2)
22858 delete arg2;
22859 }
22860 return resultobj;
22861 fail:
22862 {
22863 if (temp2)
22864 delete arg2;
22865 }
22866 return NULL;
22867 }
22868
22869
22870 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22871 PyObject *resultobj;
22872 wxPyApp *arg1 = (wxPyApp *) 0 ;
22873 wxString *result;
22874 PyObject * obj0 = 0 ;
22875 char *kwnames[] = {
22876 (char *) "self", NULL
22877 };
22878
22879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22881 if (SWIG_arg_fail(1)) SWIG_fail;
22882 {
22883 PyThreadState* __tstate = wxPyBeginAllowThreads();
22884 {
22885 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22886 result = (wxString *) &_result_ref;
22887 }
22888
22889 wxPyEndAllowThreads(__tstate);
22890 if (PyErr_Occurred()) SWIG_fail;
22891 }
22892 {
22893 #if wxUSE_UNICODE
22894 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22895 #else
22896 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22897 #endif
22898 }
22899 return resultobj;
22900 fail:
22901 return NULL;
22902 }
22903
22904
22905 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22906 PyObject *resultobj;
22907 wxPyApp *arg1 = (wxPyApp *) 0 ;
22908 wxString *arg2 = 0 ;
22909 bool temp2 = false ;
22910 PyObject * obj0 = 0 ;
22911 PyObject * obj1 = 0 ;
22912 char *kwnames[] = {
22913 (char *) "self",(char *) "name", NULL
22914 };
22915
22916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22918 if (SWIG_arg_fail(1)) SWIG_fail;
22919 {
22920 arg2 = wxString_in_helper(obj1);
22921 if (arg2 == NULL) SWIG_fail;
22922 temp2 = true;
22923 }
22924 {
22925 PyThreadState* __tstate = wxPyBeginAllowThreads();
22926 (arg1)->SetVendorName((wxString const &)*arg2);
22927
22928 wxPyEndAllowThreads(__tstate);
22929 if (PyErr_Occurred()) SWIG_fail;
22930 }
22931 Py_INCREF(Py_None); resultobj = Py_None;
22932 {
22933 if (temp2)
22934 delete arg2;
22935 }
22936 return resultobj;
22937 fail:
22938 {
22939 if (temp2)
22940 delete arg2;
22941 }
22942 return NULL;
22943 }
22944
22945
22946 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22947 PyObject *resultobj;
22948 wxPyApp *arg1 = (wxPyApp *) 0 ;
22949 wxAppTraits *result;
22950 PyObject * obj0 = 0 ;
22951 char *kwnames[] = {
22952 (char *) "self", NULL
22953 };
22954
22955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22957 if (SWIG_arg_fail(1)) SWIG_fail;
22958 {
22959 PyThreadState* __tstate = wxPyBeginAllowThreads();
22960 result = (wxAppTraits *)(arg1)->GetTraits();
22961
22962 wxPyEndAllowThreads(__tstate);
22963 if (PyErr_Occurred()) SWIG_fail;
22964 }
22965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22966 return resultobj;
22967 fail:
22968 return NULL;
22969 }
22970
22971
22972 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22973 PyObject *resultobj;
22974 wxPyApp *arg1 = (wxPyApp *) 0 ;
22975 PyObject * obj0 = 0 ;
22976 char *kwnames[] = {
22977 (char *) "self", NULL
22978 };
22979
22980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22982 if (SWIG_arg_fail(1)) SWIG_fail;
22983 {
22984 PyThreadState* __tstate = wxPyBeginAllowThreads();
22985 (arg1)->ProcessPendingEvents();
22986
22987 wxPyEndAllowThreads(__tstate);
22988 if (PyErr_Occurred()) SWIG_fail;
22989 }
22990 Py_INCREF(Py_None); resultobj = Py_None;
22991 return resultobj;
22992 fail:
22993 return NULL;
22994 }
22995
22996
22997 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22998 PyObject *resultobj;
22999 wxPyApp *arg1 = (wxPyApp *) 0 ;
23000 bool arg2 = (bool) false ;
23001 bool result;
23002 PyObject * obj0 = 0 ;
23003 PyObject * obj1 = 0 ;
23004 char *kwnames[] = {
23005 (char *) "self",(char *) "onlyIfNeeded", NULL
23006 };
23007
23008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23010 if (SWIG_arg_fail(1)) SWIG_fail;
23011 if (obj1) {
23012 {
23013 arg2 = (bool)(SWIG_As_bool(obj1));
23014 if (SWIG_arg_fail(2)) SWIG_fail;
23015 }
23016 }
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 result = (bool)(arg1)->Yield(arg2);
23020
23021 wxPyEndAllowThreads(__tstate);
23022 if (PyErr_Occurred()) SWIG_fail;
23023 }
23024 {
23025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23026 }
23027 return resultobj;
23028 fail:
23029 return NULL;
23030 }
23031
23032
23033 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23034 PyObject *resultobj;
23035 wxPyApp *arg1 = (wxPyApp *) 0 ;
23036 PyObject * obj0 = 0 ;
23037 char *kwnames[] = {
23038 (char *) "self", NULL
23039 };
23040
23041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23043 if (SWIG_arg_fail(1)) SWIG_fail;
23044 {
23045 PyThreadState* __tstate = wxPyBeginAllowThreads();
23046 (arg1)->WakeUpIdle();
23047
23048 wxPyEndAllowThreads(__tstate);
23049 if (PyErr_Occurred()) SWIG_fail;
23050 }
23051 Py_INCREF(Py_None); resultobj = Py_None;
23052 return resultobj;
23053 fail:
23054 return NULL;
23055 }
23056
23057
23058 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23059 PyObject *resultobj;
23060 bool result;
23061 char *kwnames[] = {
23062 NULL
23063 };
23064
23065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23066 {
23067 PyThreadState* __tstate = wxPyBeginAllowThreads();
23068 result = (bool)wxPyApp::IsMainLoopRunning();
23069
23070 wxPyEndAllowThreads(__tstate);
23071 if (PyErr_Occurred()) SWIG_fail;
23072 }
23073 {
23074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23075 }
23076 return resultobj;
23077 fail:
23078 return NULL;
23079 }
23080
23081
23082 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23083 PyObject *resultobj;
23084 wxPyApp *arg1 = (wxPyApp *) 0 ;
23085 int result;
23086 PyObject * obj0 = 0 ;
23087 char *kwnames[] = {
23088 (char *) "self", NULL
23089 };
23090
23091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23093 if (SWIG_arg_fail(1)) SWIG_fail;
23094 {
23095 PyThreadState* __tstate = wxPyBeginAllowThreads();
23096 result = (int)(arg1)->MainLoop();
23097
23098 wxPyEndAllowThreads(__tstate);
23099 if (PyErr_Occurred()) SWIG_fail;
23100 }
23101 {
23102 resultobj = SWIG_From_int((int)(result));
23103 }
23104 return resultobj;
23105 fail:
23106 return NULL;
23107 }
23108
23109
23110 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23111 PyObject *resultobj;
23112 wxPyApp *arg1 = (wxPyApp *) 0 ;
23113 PyObject * obj0 = 0 ;
23114 char *kwnames[] = {
23115 (char *) "self", NULL
23116 };
23117
23118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23120 if (SWIG_arg_fail(1)) SWIG_fail;
23121 {
23122 PyThreadState* __tstate = wxPyBeginAllowThreads();
23123 (arg1)->Exit();
23124
23125 wxPyEndAllowThreads(__tstate);
23126 if (PyErr_Occurred()) SWIG_fail;
23127 }
23128 Py_INCREF(Py_None); resultobj = Py_None;
23129 return resultobj;
23130 fail:
23131 return NULL;
23132 }
23133
23134
23135 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23136 PyObject *resultobj;
23137 wxPyApp *arg1 = (wxPyApp *) 0 ;
23138 PyObject * obj0 = 0 ;
23139 char *kwnames[] = {
23140 (char *) "self", NULL
23141 };
23142
23143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23145 if (SWIG_arg_fail(1)) SWIG_fail;
23146 {
23147 PyThreadState* __tstate = wxPyBeginAllowThreads();
23148 (arg1)->ExitMainLoop();
23149
23150 wxPyEndAllowThreads(__tstate);
23151 if (PyErr_Occurred()) SWIG_fail;
23152 }
23153 Py_INCREF(Py_None); resultobj = Py_None;
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23161 PyObject *resultobj;
23162 wxPyApp *arg1 = (wxPyApp *) 0 ;
23163 bool result;
23164 PyObject * obj0 = 0 ;
23165 char *kwnames[] = {
23166 (char *) "self", NULL
23167 };
23168
23169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23171 if (SWIG_arg_fail(1)) SWIG_fail;
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 result = (bool)(arg1)->Pending();
23175
23176 wxPyEndAllowThreads(__tstate);
23177 if (PyErr_Occurred()) SWIG_fail;
23178 }
23179 {
23180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23181 }
23182 return resultobj;
23183 fail:
23184 return NULL;
23185 }
23186
23187
23188 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23189 PyObject *resultobj;
23190 wxPyApp *arg1 = (wxPyApp *) 0 ;
23191 bool result;
23192 PyObject * obj0 = 0 ;
23193 char *kwnames[] = {
23194 (char *) "self", NULL
23195 };
23196
23197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23199 if (SWIG_arg_fail(1)) SWIG_fail;
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 result = (bool)(arg1)->Dispatch();
23203
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 {
23208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23209 }
23210 return resultobj;
23211 fail:
23212 return NULL;
23213 }
23214
23215
23216 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23217 PyObject *resultobj;
23218 wxPyApp *arg1 = (wxPyApp *) 0 ;
23219 bool result;
23220 PyObject * obj0 = 0 ;
23221 char *kwnames[] = {
23222 (char *) "self", NULL
23223 };
23224
23225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23227 if (SWIG_arg_fail(1)) SWIG_fail;
23228 {
23229 PyThreadState* __tstate = wxPyBeginAllowThreads();
23230 result = (bool)(arg1)->ProcessIdle();
23231
23232 wxPyEndAllowThreads(__tstate);
23233 if (PyErr_Occurred()) SWIG_fail;
23234 }
23235 {
23236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23237 }
23238 return resultobj;
23239 fail:
23240 return NULL;
23241 }
23242
23243
23244 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23245 PyObject *resultobj;
23246 wxPyApp *arg1 = (wxPyApp *) 0 ;
23247 wxWindow *arg2 = (wxWindow *) 0 ;
23248 wxIdleEvent *arg3 = 0 ;
23249 bool result;
23250 PyObject * obj0 = 0 ;
23251 PyObject * obj1 = 0 ;
23252 PyObject * obj2 = 0 ;
23253 char *kwnames[] = {
23254 (char *) "self",(char *) "win",(char *) "event", NULL
23255 };
23256
23257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23259 if (SWIG_arg_fail(1)) SWIG_fail;
23260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23261 if (SWIG_arg_fail(2)) SWIG_fail;
23262 {
23263 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23264 if (SWIG_arg_fail(3)) SWIG_fail;
23265 if (arg3 == NULL) {
23266 SWIG_null_ref("wxIdleEvent");
23267 }
23268 if (SWIG_arg_fail(3)) SWIG_fail;
23269 }
23270 {
23271 PyThreadState* __tstate = wxPyBeginAllowThreads();
23272 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23273
23274 wxPyEndAllowThreads(__tstate);
23275 if (PyErr_Occurred()) SWIG_fail;
23276 }
23277 {
23278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23279 }
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23287 PyObject *resultobj;
23288 wxPyApp *arg1 = (wxPyApp *) 0 ;
23289 bool result;
23290 PyObject * obj0 = 0 ;
23291 char *kwnames[] = {
23292 (char *) "self", NULL
23293 };
23294
23295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23297 if (SWIG_arg_fail(1)) SWIG_fail;
23298 {
23299 PyThreadState* __tstate = wxPyBeginAllowThreads();
23300 result = (bool)((wxPyApp const *)arg1)->IsActive();
23301
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 {
23306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23307 }
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23315 PyObject *resultobj;
23316 wxPyApp *arg1 = (wxPyApp *) 0 ;
23317 wxWindow *arg2 = (wxWindow *) 0 ;
23318 PyObject * obj0 = 0 ;
23319 PyObject * obj1 = 0 ;
23320 char *kwnames[] = {
23321 (char *) "self",(char *) "win", NULL
23322 };
23323
23324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23326 if (SWIG_arg_fail(1)) SWIG_fail;
23327 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23328 if (SWIG_arg_fail(2)) SWIG_fail;
23329 {
23330 PyThreadState* __tstate = wxPyBeginAllowThreads();
23331 (arg1)->SetTopWindow(arg2);
23332
23333 wxPyEndAllowThreads(__tstate);
23334 if (PyErr_Occurred()) SWIG_fail;
23335 }
23336 Py_INCREF(Py_None); resultobj = Py_None;
23337 return resultobj;
23338 fail:
23339 return NULL;
23340 }
23341
23342
23343 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23344 PyObject *resultobj;
23345 wxPyApp *arg1 = (wxPyApp *) 0 ;
23346 wxWindow *result;
23347 PyObject * obj0 = 0 ;
23348 char *kwnames[] = {
23349 (char *) "self", NULL
23350 };
23351
23352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23354 if (SWIG_arg_fail(1)) SWIG_fail;
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23358
23359 wxPyEndAllowThreads(__tstate);
23360 if (PyErr_Occurred()) SWIG_fail;
23361 }
23362 {
23363 resultobj = wxPyMake_wxObject(result, 0);
23364 }
23365 return resultobj;
23366 fail:
23367 return NULL;
23368 }
23369
23370
23371 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23372 PyObject *resultobj;
23373 wxPyApp *arg1 = (wxPyApp *) 0 ;
23374 bool arg2 ;
23375 PyObject * obj0 = 0 ;
23376 PyObject * obj1 = 0 ;
23377 char *kwnames[] = {
23378 (char *) "self",(char *) "flag", NULL
23379 };
23380
23381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23383 if (SWIG_arg_fail(1)) SWIG_fail;
23384 {
23385 arg2 = (bool)(SWIG_As_bool(obj1));
23386 if (SWIG_arg_fail(2)) SWIG_fail;
23387 }
23388 {
23389 PyThreadState* __tstate = wxPyBeginAllowThreads();
23390 (arg1)->SetExitOnFrameDelete(arg2);
23391
23392 wxPyEndAllowThreads(__tstate);
23393 if (PyErr_Occurred()) SWIG_fail;
23394 }
23395 Py_INCREF(Py_None); resultobj = Py_None;
23396 return resultobj;
23397 fail:
23398 return NULL;
23399 }
23400
23401
23402 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23403 PyObject *resultobj;
23404 wxPyApp *arg1 = (wxPyApp *) 0 ;
23405 bool result;
23406 PyObject * obj0 = 0 ;
23407 char *kwnames[] = {
23408 (char *) "self", NULL
23409 };
23410
23411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23413 if (SWIG_arg_fail(1)) SWIG_fail;
23414 {
23415 PyThreadState* __tstate = wxPyBeginAllowThreads();
23416 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23417
23418 wxPyEndAllowThreads(__tstate);
23419 if (PyErr_Occurred()) SWIG_fail;
23420 }
23421 {
23422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23423 }
23424 return resultobj;
23425 fail:
23426 return NULL;
23427 }
23428
23429
23430 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23431 PyObject *resultobj;
23432 wxPyApp *arg1 = (wxPyApp *) 0 ;
23433 bool arg2 ;
23434 PyObject * obj0 = 0 ;
23435 PyObject * obj1 = 0 ;
23436 char *kwnames[] = {
23437 (char *) "self",(char *) "flag", NULL
23438 };
23439
23440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23442 if (SWIG_arg_fail(1)) SWIG_fail;
23443 {
23444 arg2 = (bool)(SWIG_As_bool(obj1));
23445 if (SWIG_arg_fail(2)) SWIG_fail;
23446 }
23447 {
23448 PyThreadState* __tstate = wxPyBeginAllowThreads();
23449 (arg1)->SetUseBestVisual(arg2);
23450
23451 wxPyEndAllowThreads(__tstate);
23452 if (PyErr_Occurred()) SWIG_fail;
23453 }
23454 Py_INCREF(Py_None); resultobj = Py_None;
23455 return resultobj;
23456 fail:
23457 return NULL;
23458 }
23459
23460
23461 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23462 PyObject *resultobj;
23463 wxPyApp *arg1 = (wxPyApp *) 0 ;
23464 bool result;
23465 PyObject * obj0 = 0 ;
23466 char *kwnames[] = {
23467 (char *) "self", NULL
23468 };
23469
23470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23472 if (SWIG_arg_fail(1)) SWIG_fail;
23473 {
23474 PyThreadState* __tstate = wxPyBeginAllowThreads();
23475 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23476
23477 wxPyEndAllowThreads(__tstate);
23478 if (PyErr_Occurred()) SWIG_fail;
23479 }
23480 {
23481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23482 }
23483 return resultobj;
23484 fail:
23485 return NULL;
23486 }
23487
23488
23489 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23490 PyObject *resultobj;
23491 wxPyApp *arg1 = (wxPyApp *) 0 ;
23492 int arg2 ;
23493 PyObject * obj0 = 0 ;
23494 PyObject * obj1 = 0 ;
23495 char *kwnames[] = {
23496 (char *) "self",(char *) "mode", NULL
23497 };
23498
23499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23501 if (SWIG_arg_fail(1)) SWIG_fail;
23502 {
23503 arg2 = (int)(SWIG_As_int(obj1));
23504 if (SWIG_arg_fail(2)) SWIG_fail;
23505 }
23506 {
23507 PyThreadState* __tstate = wxPyBeginAllowThreads();
23508 (arg1)->SetPrintMode(arg2);
23509
23510 wxPyEndAllowThreads(__tstate);
23511 if (PyErr_Occurred()) SWIG_fail;
23512 }
23513 Py_INCREF(Py_None); resultobj = Py_None;
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23521 PyObject *resultobj;
23522 wxPyApp *arg1 = (wxPyApp *) 0 ;
23523 int result;
23524 PyObject * obj0 = 0 ;
23525 char *kwnames[] = {
23526 (char *) "self", NULL
23527 };
23528
23529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23531 if (SWIG_arg_fail(1)) SWIG_fail;
23532 {
23533 PyThreadState* __tstate = wxPyBeginAllowThreads();
23534 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23535
23536 wxPyEndAllowThreads(__tstate);
23537 if (PyErr_Occurred()) SWIG_fail;
23538 }
23539 {
23540 resultobj = SWIG_From_int((int)(result));
23541 }
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23549 PyObject *resultobj;
23550 wxPyApp *arg1 = (wxPyApp *) 0 ;
23551 int arg2 ;
23552 PyObject * obj0 = 0 ;
23553 PyObject * obj1 = 0 ;
23554 char *kwnames[] = {
23555 (char *) "self",(char *) "mode", NULL
23556 };
23557
23558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23560 if (SWIG_arg_fail(1)) SWIG_fail;
23561 {
23562 arg2 = (int)(SWIG_As_int(obj1));
23563 if (SWIG_arg_fail(2)) SWIG_fail;
23564 }
23565 {
23566 PyThreadState* __tstate = wxPyBeginAllowThreads();
23567 (arg1)->SetAssertMode(arg2);
23568
23569 wxPyEndAllowThreads(__tstate);
23570 if (PyErr_Occurred()) SWIG_fail;
23571 }
23572 Py_INCREF(Py_None); resultobj = Py_None;
23573 return resultobj;
23574 fail:
23575 return NULL;
23576 }
23577
23578
23579 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23580 PyObject *resultobj;
23581 wxPyApp *arg1 = (wxPyApp *) 0 ;
23582 int result;
23583 PyObject * obj0 = 0 ;
23584 char *kwnames[] = {
23585 (char *) "self", NULL
23586 };
23587
23588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23590 if (SWIG_arg_fail(1)) SWIG_fail;
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (int)(arg1)->GetAssertMode();
23594
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 {
23599 resultobj = SWIG_From_int((int)(result));
23600 }
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23608 PyObject *resultobj;
23609 bool result;
23610 char *kwnames[] = {
23611 NULL
23612 };
23613
23614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23615 {
23616 PyThreadState* __tstate = wxPyBeginAllowThreads();
23617 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23618
23619 wxPyEndAllowThreads(__tstate);
23620 if (PyErr_Occurred()) SWIG_fail;
23621 }
23622 {
23623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23624 }
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23632 PyObject *resultobj;
23633 long result;
23634 char *kwnames[] = {
23635 NULL
23636 };
23637
23638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23639 {
23640 PyThreadState* __tstate = wxPyBeginAllowThreads();
23641 result = (long)wxPyApp::GetMacAboutMenuItemId();
23642
23643 wxPyEndAllowThreads(__tstate);
23644 if (PyErr_Occurred()) SWIG_fail;
23645 }
23646 {
23647 resultobj = SWIG_From_long((long)(result));
23648 }
23649 return resultobj;
23650 fail:
23651 return NULL;
23652 }
23653
23654
23655 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23656 PyObject *resultobj;
23657 long result;
23658 char *kwnames[] = {
23659 NULL
23660 };
23661
23662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23663 {
23664 PyThreadState* __tstate = wxPyBeginAllowThreads();
23665 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23666
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 {
23671 resultobj = SWIG_From_long((long)(result));
23672 }
23673 return resultobj;
23674 fail:
23675 return NULL;
23676 }
23677
23678
23679 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23680 PyObject *resultobj;
23681 long result;
23682 char *kwnames[] = {
23683 NULL
23684 };
23685
23686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23687 {
23688 PyThreadState* __tstate = wxPyBeginAllowThreads();
23689 result = (long)wxPyApp::GetMacExitMenuItemId();
23690
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 {
23695 resultobj = SWIG_From_long((long)(result));
23696 }
23697 return resultobj;
23698 fail:
23699 return NULL;
23700 }
23701
23702
23703 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23704 PyObject *resultobj;
23705 wxString result;
23706 char *kwnames[] = {
23707 NULL
23708 };
23709
23710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23711 {
23712 PyThreadState* __tstate = wxPyBeginAllowThreads();
23713 result = wxPyApp::GetMacHelpMenuTitleName();
23714
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 {
23719 #if wxUSE_UNICODE
23720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23721 #else
23722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23723 #endif
23724 }
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23732 PyObject *resultobj;
23733 bool arg1 ;
23734 PyObject * obj0 = 0 ;
23735 char *kwnames[] = {
23736 (char *) "val", NULL
23737 };
23738
23739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23740 {
23741 arg1 = (bool)(SWIG_As_bool(obj0));
23742 if (SWIG_arg_fail(1)) SWIG_fail;
23743 }
23744 {
23745 PyThreadState* __tstate = wxPyBeginAllowThreads();
23746 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23747
23748 wxPyEndAllowThreads(__tstate);
23749 if (PyErr_Occurred()) SWIG_fail;
23750 }
23751 Py_INCREF(Py_None); resultobj = Py_None;
23752 return resultobj;
23753 fail:
23754 return NULL;
23755 }
23756
23757
23758 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23759 PyObject *resultobj;
23760 long arg1 ;
23761 PyObject * obj0 = 0 ;
23762 char *kwnames[] = {
23763 (char *) "val", NULL
23764 };
23765
23766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23767 {
23768 arg1 = (long)(SWIG_As_long(obj0));
23769 if (SWIG_arg_fail(1)) SWIG_fail;
23770 }
23771 {
23772 PyThreadState* __tstate = wxPyBeginAllowThreads();
23773 wxPyApp::SetMacAboutMenuItemId(arg1);
23774
23775 wxPyEndAllowThreads(__tstate);
23776 if (PyErr_Occurred()) SWIG_fail;
23777 }
23778 Py_INCREF(Py_None); resultobj = Py_None;
23779 return resultobj;
23780 fail:
23781 return NULL;
23782 }
23783
23784
23785 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23786 PyObject *resultobj;
23787 long arg1 ;
23788 PyObject * obj0 = 0 ;
23789 char *kwnames[] = {
23790 (char *) "val", NULL
23791 };
23792
23793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23794 {
23795 arg1 = (long)(SWIG_As_long(obj0));
23796 if (SWIG_arg_fail(1)) SWIG_fail;
23797 }
23798 {
23799 PyThreadState* __tstate = wxPyBeginAllowThreads();
23800 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23801
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 Py_INCREF(Py_None); resultobj = Py_None;
23806 return resultobj;
23807 fail:
23808 return NULL;
23809 }
23810
23811
23812 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23813 PyObject *resultobj;
23814 long arg1 ;
23815 PyObject * obj0 = 0 ;
23816 char *kwnames[] = {
23817 (char *) "val", NULL
23818 };
23819
23820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23821 {
23822 arg1 = (long)(SWIG_As_long(obj0));
23823 if (SWIG_arg_fail(1)) SWIG_fail;
23824 }
23825 {
23826 PyThreadState* __tstate = wxPyBeginAllowThreads();
23827 wxPyApp::SetMacExitMenuItemId(arg1);
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_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23840 PyObject *resultobj;
23841 wxString *arg1 = 0 ;
23842 bool temp1 = false ;
23843 PyObject * obj0 = 0 ;
23844 char *kwnames[] = {
23845 (char *) "val", NULL
23846 };
23847
23848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23849 {
23850 arg1 = wxString_in_helper(obj0);
23851 if (arg1 == NULL) SWIG_fail;
23852 temp1 = true;
23853 }
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23857
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 Py_INCREF(Py_None); resultobj = Py_None;
23862 {
23863 if (temp1)
23864 delete arg1;
23865 }
23866 return resultobj;
23867 fail:
23868 {
23869 if (temp1)
23870 delete arg1;
23871 }
23872 return NULL;
23873 }
23874
23875
23876 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23877 PyObject *resultobj;
23878 wxPyApp *arg1 = (wxPyApp *) 0 ;
23879 PyObject * obj0 = 0 ;
23880 char *kwnames[] = {
23881 (char *) "self", NULL
23882 };
23883
23884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23886 if (SWIG_arg_fail(1)) SWIG_fail;
23887 {
23888 PyThreadState* __tstate = wxPyBeginAllowThreads();
23889 (arg1)->_BootstrapApp();
23890
23891 wxPyEndAllowThreads(__tstate);
23892 if (PyErr_Occurred()) SWIG_fail;
23893 }
23894 Py_INCREF(Py_None); resultobj = Py_None;
23895 return resultobj;
23896 fail:
23897 return NULL;
23898 }
23899
23900
23901 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23902 PyObject *resultobj;
23903 int result;
23904 char *kwnames[] = {
23905 NULL
23906 };
23907
23908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23909 {
23910 PyThreadState* __tstate = wxPyBeginAllowThreads();
23911 result = (int)PyApp_GetComCtl32Version();
23912
23913 wxPyEndAllowThreads(__tstate);
23914 if (PyErr_Occurred()) SWIG_fail;
23915 }
23916 {
23917 resultobj = SWIG_From_int((int)(result));
23918 }
23919 return resultobj;
23920 fail:
23921 return NULL;
23922 }
23923
23924
23925 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23926 PyObject *obj;
23927 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23928 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23929 Py_INCREF(obj);
23930 return Py_BuildValue((char *)"");
23931 }
23932 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23933 PyObject *resultobj;
23934 char *kwnames[] = {
23935 NULL
23936 };
23937
23938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23939 {
23940 PyThreadState* __tstate = wxPyBeginAllowThreads();
23941 wxExit();
23942
23943 wxPyEndAllowThreads(__tstate);
23944 if (PyErr_Occurred()) SWIG_fail;
23945 }
23946 Py_INCREF(Py_None); resultobj = Py_None;
23947 return resultobj;
23948 fail:
23949 return NULL;
23950 }
23951
23952
23953 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23954 PyObject *resultobj;
23955 bool result;
23956 char *kwnames[] = {
23957 NULL
23958 };
23959
23960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 result = (bool)wxYield();
23964
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 {
23969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23970 }
23971 return resultobj;
23972 fail:
23973 return NULL;
23974 }
23975
23976
23977 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23978 PyObject *resultobj;
23979 bool result;
23980 char *kwnames[] = {
23981 NULL
23982 };
23983
23984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23985 {
23986 PyThreadState* __tstate = wxPyBeginAllowThreads();
23987 result = (bool)wxYieldIfNeeded();
23988
23989 wxPyEndAllowThreads(__tstate);
23990 if (PyErr_Occurred()) SWIG_fail;
23991 }
23992 {
23993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23994 }
23995 return resultobj;
23996 fail:
23997 return NULL;
23998 }
23999
24000
24001 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24002 PyObject *resultobj;
24003 wxWindow *arg1 = (wxWindow *) NULL ;
24004 bool arg2 = (bool) false ;
24005 bool result;
24006 PyObject * obj0 = 0 ;
24007 PyObject * obj1 = 0 ;
24008 char *kwnames[] = {
24009 (char *) "win",(char *) "onlyIfNeeded", NULL
24010 };
24011
24012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24013 if (obj0) {
24014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24015 if (SWIG_arg_fail(1)) SWIG_fail;
24016 }
24017 if (obj1) {
24018 {
24019 arg2 = (bool)(SWIG_As_bool(obj1));
24020 if (SWIG_arg_fail(2)) SWIG_fail;
24021 }
24022 }
24023 {
24024 PyThreadState* __tstate = wxPyBeginAllowThreads();
24025 result = (bool)wxSafeYield(arg1,arg2);
24026
24027 wxPyEndAllowThreads(__tstate);
24028 if (PyErr_Occurred()) SWIG_fail;
24029 }
24030 {
24031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24032 }
24033 return resultobj;
24034 fail:
24035 return NULL;
24036 }
24037
24038
24039 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24040 PyObject *resultobj;
24041 char *kwnames[] = {
24042 NULL
24043 };
24044
24045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24046 {
24047 PyThreadState* __tstate = wxPyBeginAllowThreads();
24048 wxWakeUpIdle();
24049
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 Py_INCREF(Py_None); resultobj = Py_None;
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24061 PyObject *resultobj;
24062 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24063 wxEvent *arg2 = 0 ;
24064 PyObject * obj0 = 0 ;
24065 PyObject * obj1 = 0 ;
24066 char *kwnames[] = {
24067 (char *) "dest",(char *) "event", NULL
24068 };
24069
24070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24072 if (SWIG_arg_fail(1)) SWIG_fail;
24073 {
24074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24075 if (SWIG_arg_fail(2)) SWIG_fail;
24076 if (arg2 == NULL) {
24077 SWIG_null_ref("wxEvent");
24078 }
24079 if (SWIG_arg_fail(2)) SWIG_fail;
24080 }
24081 {
24082 PyThreadState* __tstate = wxPyBeginAllowThreads();
24083 wxPostEvent(arg1,*arg2);
24084
24085 wxPyEndAllowThreads(__tstate);
24086 if (PyErr_Occurred()) SWIG_fail;
24087 }
24088 Py_INCREF(Py_None); resultobj = Py_None;
24089 return resultobj;
24090 fail:
24091 return NULL;
24092 }
24093
24094
24095 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24096 PyObject *resultobj;
24097 char *kwnames[] = {
24098 NULL
24099 };
24100
24101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24102 {
24103 PyThreadState* __tstate = wxPyBeginAllowThreads();
24104 wxApp_CleanUp();
24105
24106 wxPyEndAllowThreads(__tstate);
24107 if (PyErr_Occurred()) SWIG_fail;
24108 }
24109 Py_INCREF(Py_None); resultobj = Py_None;
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24117 PyObject *resultobj;
24118 wxPyApp *result;
24119 char *kwnames[] = {
24120 NULL
24121 };
24122
24123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 result = (wxPyApp *)wxPyGetApp();
24127
24128 wxPyEndAllowThreads(__tstate);
24129 if (PyErr_Occurred()) SWIG_fail;
24130 }
24131 {
24132 resultobj = wxPyMake_wxObject(result, 0);
24133 }
24134 return resultobj;
24135 fail:
24136 return NULL;
24137 }
24138
24139
24140 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24141 PyObject *resultobj;
24142 char *arg1 = (char *) 0 ;
24143 PyObject * obj0 = 0 ;
24144 char *kwnames[] = {
24145 (char *) "encoding", NULL
24146 };
24147
24148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24149 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24150 SWIG_arg_fail(1);SWIG_fail;
24151 }
24152 {
24153 PyThreadState* __tstate = wxPyBeginAllowThreads();
24154 wxSetDefaultPyEncoding((char const *)arg1);
24155
24156 wxPyEndAllowThreads(__tstate);
24157 if (PyErr_Occurred()) SWIG_fail;
24158 }
24159 Py_INCREF(Py_None); resultobj = Py_None;
24160 return resultobj;
24161 fail:
24162 return NULL;
24163 }
24164
24165
24166 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24167 PyObject *resultobj;
24168 char *result;
24169 char *kwnames[] = {
24170 NULL
24171 };
24172
24173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24174 {
24175 PyThreadState* __tstate = wxPyBeginAllowThreads();
24176 result = (char *)wxGetDefaultPyEncoding();
24177
24178 wxPyEndAllowThreads(__tstate);
24179 if (PyErr_Occurred()) SWIG_fail;
24180 }
24181 resultobj = SWIG_FromCharPtr(result);
24182 return resultobj;
24183 fail:
24184 return NULL;
24185 }
24186
24187
24188 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24189 PyObject *resultobj;
24190 wxEventLoop *result;
24191 char *kwnames[] = {
24192 NULL
24193 };
24194
24195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24196 {
24197 PyThreadState* __tstate = wxPyBeginAllowThreads();
24198 result = (wxEventLoop *)new wxEventLoop();
24199
24200 wxPyEndAllowThreads(__tstate);
24201 if (PyErr_Occurred()) SWIG_fail;
24202 }
24203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24204 return resultobj;
24205 fail:
24206 return NULL;
24207 }
24208
24209
24210 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24211 PyObject *resultobj;
24212 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24213 PyObject * obj0 = 0 ;
24214 char *kwnames[] = {
24215 (char *) "self", NULL
24216 };
24217
24218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24220 if (SWIG_arg_fail(1)) SWIG_fail;
24221 {
24222 PyThreadState* __tstate = wxPyBeginAllowThreads();
24223 delete arg1;
24224
24225 wxPyEndAllowThreads(__tstate);
24226 if (PyErr_Occurred()) SWIG_fail;
24227 }
24228 Py_INCREF(Py_None); resultobj = Py_None;
24229 return resultobj;
24230 fail:
24231 return NULL;
24232 }
24233
24234
24235 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24236 PyObject *resultobj;
24237 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24238 int result;
24239 PyObject * obj0 = 0 ;
24240 char *kwnames[] = {
24241 (char *) "self", NULL
24242 };
24243
24244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24246 if (SWIG_arg_fail(1)) SWIG_fail;
24247 {
24248 PyThreadState* __tstate = wxPyBeginAllowThreads();
24249 result = (int)(arg1)->Run();
24250
24251 wxPyEndAllowThreads(__tstate);
24252 if (PyErr_Occurred()) SWIG_fail;
24253 }
24254 {
24255 resultobj = SWIG_From_int((int)(result));
24256 }
24257 return resultobj;
24258 fail:
24259 return NULL;
24260 }
24261
24262
24263 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24264 PyObject *resultobj;
24265 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24266 int arg2 = (int) 0 ;
24267 PyObject * obj0 = 0 ;
24268 PyObject * obj1 = 0 ;
24269 char *kwnames[] = {
24270 (char *) "self",(char *) "rc", NULL
24271 };
24272
24273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24275 if (SWIG_arg_fail(1)) SWIG_fail;
24276 if (obj1) {
24277 {
24278 arg2 = (int)(SWIG_As_int(obj1));
24279 if (SWIG_arg_fail(2)) SWIG_fail;
24280 }
24281 }
24282 {
24283 PyThreadState* __tstate = wxPyBeginAllowThreads();
24284 (arg1)->Exit(arg2);
24285
24286 wxPyEndAllowThreads(__tstate);
24287 if (PyErr_Occurred()) SWIG_fail;
24288 }
24289 Py_INCREF(Py_None); resultobj = Py_None;
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24297 PyObject *resultobj;
24298 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24299 bool result;
24300 PyObject * obj0 = 0 ;
24301 char *kwnames[] = {
24302 (char *) "self", NULL
24303 };
24304
24305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24307 if (SWIG_arg_fail(1)) SWIG_fail;
24308 {
24309 PyThreadState* __tstate = wxPyBeginAllowThreads();
24310 result = (bool)((wxEventLoop const *)arg1)->Pending();
24311
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 {
24316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24317 }
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24325 PyObject *resultobj;
24326 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24327 bool result;
24328 PyObject * obj0 = 0 ;
24329 char *kwnames[] = {
24330 (char *) "self", NULL
24331 };
24332
24333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24335 if (SWIG_arg_fail(1)) SWIG_fail;
24336 {
24337 PyThreadState* __tstate = wxPyBeginAllowThreads();
24338 result = (bool)(arg1)->Dispatch();
24339
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 {
24344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24345 }
24346 return resultobj;
24347 fail:
24348 return NULL;
24349 }
24350
24351
24352 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24353 PyObject *resultobj;
24354 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24355 bool result;
24356 PyObject * obj0 = 0 ;
24357 char *kwnames[] = {
24358 (char *) "self", NULL
24359 };
24360
24361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24363 if (SWIG_arg_fail(1)) SWIG_fail;
24364 {
24365 PyThreadState* __tstate = wxPyBeginAllowThreads();
24366 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24367
24368 wxPyEndAllowThreads(__tstate);
24369 if (PyErr_Occurred()) SWIG_fail;
24370 }
24371 {
24372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24373 }
24374 return resultobj;
24375 fail:
24376 return NULL;
24377 }
24378
24379
24380 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24381 PyObject *resultobj;
24382 wxEventLoop *result;
24383 char *kwnames[] = {
24384 NULL
24385 };
24386
24387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24388 {
24389 PyThreadState* __tstate = wxPyBeginAllowThreads();
24390 result = (wxEventLoop *)wxEventLoop::GetActive();
24391
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24396 return resultobj;
24397 fail:
24398 return NULL;
24399 }
24400
24401
24402 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24403 PyObject *resultobj;
24404 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24405 PyObject * obj0 = 0 ;
24406 char *kwnames[] = {
24407 (char *) "loop", NULL
24408 };
24409
24410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24412 if (SWIG_arg_fail(1)) SWIG_fail;
24413 {
24414 PyThreadState* __tstate = wxPyBeginAllowThreads();
24415 wxEventLoop::SetActive(arg1);
24416
24417 wxPyEndAllowThreads(__tstate);
24418 if (PyErr_Occurred()) SWIG_fail;
24419 }
24420 Py_INCREF(Py_None); resultobj = Py_None;
24421 return resultobj;
24422 fail:
24423 return NULL;
24424 }
24425
24426
24427 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24428 PyObject *obj;
24429 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24430 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24431 Py_INCREF(obj);
24432 return Py_BuildValue((char *)"");
24433 }
24434 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24435 PyObject *resultobj;
24436 int arg1 = (int) 0 ;
24437 int arg2 = (int) 0 ;
24438 int arg3 = (int) 0 ;
24439 wxAcceleratorEntry *result;
24440 PyObject * obj0 = 0 ;
24441 PyObject * obj1 = 0 ;
24442 PyObject * obj2 = 0 ;
24443 char *kwnames[] = {
24444 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24445 };
24446
24447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24448 if (obj0) {
24449 {
24450 arg1 = (int)(SWIG_As_int(obj0));
24451 if (SWIG_arg_fail(1)) SWIG_fail;
24452 }
24453 }
24454 if (obj1) {
24455 {
24456 arg2 = (int)(SWIG_As_int(obj1));
24457 if (SWIG_arg_fail(2)) SWIG_fail;
24458 }
24459 }
24460 if (obj2) {
24461 {
24462 arg3 = (int)(SWIG_As_int(obj2));
24463 if (SWIG_arg_fail(3)) SWIG_fail;
24464 }
24465 }
24466 {
24467 PyThreadState* __tstate = wxPyBeginAllowThreads();
24468 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24469
24470 wxPyEndAllowThreads(__tstate);
24471 if (PyErr_Occurred()) SWIG_fail;
24472 }
24473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24474 return resultobj;
24475 fail:
24476 return NULL;
24477 }
24478
24479
24480 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24481 PyObject *resultobj;
24482 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24483 PyObject * obj0 = 0 ;
24484 char *kwnames[] = {
24485 (char *) "self", NULL
24486 };
24487
24488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24490 if (SWIG_arg_fail(1)) SWIG_fail;
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 delete arg1;
24494
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 Py_INCREF(Py_None); resultobj = Py_None;
24499 return resultobj;
24500 fail:
24501 return NULL;
24502 }
24503
24504
24505 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24506 PyObject *resultobj;
24507 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24508 int arg2 ;
24509 int arg3 ;
24510 int arg4 ;
24511 PyObject * obj0 = 0 ;
24512 PyObject * obj1 = 0 ;
24513 PyObject * obj2 = 0 ;
24514 PyObject * obj3 = 0 ;
24515 char *kwnames[] = {
24516 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24517 };
24518
24519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24521 if (SWIG_arg_fail(1)) SWIG_fail;
24522 {
24523 arg2 = (int)(SWIG_As_int(obj1));
24524 if (SWIG_arg_fail(2)) SWIG_fail;
24525 }
24526 {
24527 arg3 = (int)(SWIG_As_int(obj2));
24528 if (SWIG_arg_fail(3)) SWIG_fail;
24529 }
24530 {
24531 arg4 = (int)(SWIG_As_int(obj3));
24532 if (SWIG_arg_fail(4)) SWIG_fail;
24533 }
24534 {
24535 PyThreadState* __tstate = wxPyBeginAllowThreads();
24536 (arg1)->Set(arg2,arg3,arg4);
24537
24538 wxPyEndAllowThreads(__tstate);
24539 if (PyErr_Occurred()) SWIG_fail;
24540 }
24541 Py_INCREF(Py_None); resultobj = Py_None;
24542 return resultobj;
24543 fail:
24544 return NULL;
24545 }
24546
24547
24548 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24549 PyObject *resultobj;
24550 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24551 int result;
24552 PyObject * obj0 = 0 ;
24553 char *kwnames[] = {
24554 (char *) "self", NULL
24555 };
24556
24557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24559 if (SWIG_arg_fail(1)) SWIG_fail;
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 result = (int)(arg1)->GetFlags();
24563
24564 wxPyEndAllowThreads(__tstate);
24565 if (PyErr_Occurred()) SWIG_fail;
24566 }
24567 {
24568 resultobj = SWIG_From_int((int)(result));
24569 }
24570 return resultobj;
24571 fail:
24572 return NULL;
24573 }
24574
24575
24576 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24577 PyObject *resultobj;
24578 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24579 int result;
24580 PyObject * obj0 = 0 ;
24581 char *kwnames[] = {
24582 (char *) "self", NULL
24583 };
24584
24585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24587 if (SWIG_arg_fail(1)) SWIG_fail;
24588 {
24589 PyThreadState* __tstate = wxPyBeginAllowThreads();
24590 result = (int)(arg1)->GetKeyCode();
24591
24592 wxPyEndAllowThreads(__tstate);
24593 if (PyErr_Occurred()) SWIG_fail;
24594 }
24595 {
24596 resultobj = SWIG_From_int((int)(result));
24597 }
24598 return resultobj;
24599 fail:
24600 return NULL;
24601 }
24602
24603
24604 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24605 PyObject *resultobj;
24606 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24607 int result;
24608 PyObject * obj0 = 0 ;
24609 char *kwnames[] = {
24610 (char *) "self", NULL
24611 };
24612
24613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24615 if (SWIG_arg_fail(1)) SWIG_fail;
24616 {
24617 PyThreadState* __tstate = wxPyBeginAllowThreads();
24618 result = (int)(arg1)->GetCommand();
24619
24620 wxPyEndAllowThreads(__tstate);
24621 if (PyErr_Occurred()) SWIG_fail;
24622 }
24623 {
24624 resultobj = SWIG_From_int((int)(result));
24625 }
24626 return resultobj;
24627 fail:
24628 return NULL;
24629 }
24630
24631
24632 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24633 PyObject *obj;
24634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24635 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24636 Py_INCREF(obj);
24637 return Py_BuildValue((char *)"");
24638 }
24639 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24640 PyObject *resultobj;
24641 int arg1 ;
24642 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24643 wxAcceleratorTable *result;
24644 PyObject * obj0 = 0 ;
24645 char *kwnames[] = {
24646 (char *) "n", NULL
24647 };
24648
24649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24650 {
24651 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24652 if (arg2) arg1 = PyList_Size(obj0);
24653 else arg1 = 0;
24654 }
24655 {
24656 PyThreadState* __tstate = wxPyBeginAllowThreads();
24657 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24658
24659 wxPyEndAllowThreads(__tstate);
24660 if (PyErr_Occurred()) SWIG_fail;
24661 }
24662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24663 {
24664 delete [] arg2;
24665 }
24666 return resultobj;
24667 fail:
24668 {
24669 delete [] arg2;
24670 }
24671 return NULL;
24672 }
24673
24674
24675 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24676 PyObject *resultobj;
24677 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24678 PyObject * obj0 = 0 ;
24679 char *kwnames[] = {
24680 (char *) "self", NULL
24681 };
24682
24683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24685 if (SWIG_arg_fail(1)) SWIG_fail;
24686 {
24687 PyThreadState* __tstate = wxPyBeginAllowThreads();
24688 delete arg1;
24689
24690 wxPyEndAllowThreads(__tstate);
24691 if (PyErr_Occurred()) SWIG_fail;
24692 }
24693 Py_INCREF(Py_None); resultobj = Py_None;
24694 return resultobj;
24695 fail:
24696 return NULL;
24697 }
24698
24699
24700 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24701 PyObject *resultobj;
24702 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24703 bool result;
24704 PyObject * obj0 = 0 ;
24705 char *kwnames[] = {
24706 (char *) "self", NULL
24707 };
24708
24709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24711 if (SWIG_arg_fail(1)) SWIG_fail;
24712 {
24713 PyThreadState* __tstate = wxPyBeginAllowThreads();
24714 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24715
24716 wxPyEndAllowThreads(__tstate);
24717 if (PyErr_Occurred()) SWIG_fail;
24718 }
24719 {
24720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24721 }
24722 return resultobj;
24723 fail:
24724 return NULL;
24725 }
24726
24727
24728 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24729 PyObject *obj;
24730 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24731 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24732 Py_INCREF(obj);
24733 return Py_BuildValue((char *)"");
24734 }
24735 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24736 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24737 return 1;
24738 }
24739
24740
24741 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24742 PyObject *pyobj;
24743
24744 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24745 return pyobj;
24746 }
24747
24748
24749 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24750 PyObject *resultobj;
24751 wxString *arg1 = 0 ;
24752 wxAcceleratorEntry *result;
24753 bool temp1 = false ;
24754 PyObject * obj0 = 0 ;
24755 char *kwnames[] = {
24756 (char *) "label", NULL
24757 };
24758
24759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24760 {
24761 arg1 = wxString_in_helper(obj0);
24762 if (arg1 == NULL) SWIG_fail;
24763 temp1 = true;
24764 }
24765 {
24766 PyThreadState* __tstate = wxPyBeginAllowThreads();
24767 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24768
24769 wxPyEndAllowThreads(__tstate);
24770 if (PyErr_Occurred()) SWIG_fail;
24771 }
24772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24773 {
24774 if (temp1)
24775 delete arg1;
24776 }
24777 return resultobj;
24778 fail:
24779 {
24780 if (temp1)
24781 delete arg1;
24782 }
24783 return NULL;
24784 }
24785
24786
24787 static int _wrap_PanelNameStr_set(PyObject *) {
24788 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24789 return 1;
24790 }
24791
24792
24793 static PyObject *_wrap_PanelNameStr_get(void) {
24794 PyObject *pyobj;
24795
24796 {
24797 #if wxUSE_UNICODE
24798 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24799 #else
24800 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24801 #endif
24802 }
24803 return pyobj;
24804 }
24805
24806
24807 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24808 PyObject *resultobj;
24809 wxVisualAttributes *result;
24810 char *kwnames[] = {
24811 NULL
24812 };
24813
24814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 result = (wxVisualAttributes *)new_wxVisualAttributes();
24818
24819 wxPyEndAllowThreads(__tstate);
24820 if (PyErr_Occurred()) SWIG_fail;
24821 }
24822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24823 return resultobj;
24824 fail:
24825 return NULL;
24826 }
24827
24828
24829 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24830 PyObject *resultobj;
24831 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24832 PyObject * obj0 = 0 ;
24833 char *kwnames[] = {
24834 (char *) "self", NULL
24835 };
24836
24837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24839 if (SWIG_arg_fail(1)) SWIG_fail;
24840 {
24841 PyThreadState* __tstate = wxPyBeginAllowThreads();
24842 delete_wxVisualAttributes(arg1);
24843
24844 wxPyEndAllowThreads(__tstate);
24845 if (PyErr_Occurred()) SWIG_fail;
24846 }
24847 Py_INCREF(Py_None); resultobj = Py_None;
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24855 PyObject *resultobj;
24856 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24857 wxFont *arg2 = (wxFont *) 0 ;
24858 PyObject * obj0 = 0 ;
24859 PyObject * obj1 = 0 ;
24860 char *kwnames[] = {
24861 (char *) "self",(char *) "font", NULL
24862 };
24863
24864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24866 if (SWIG_arg_fail(1)) SWIG_fail;
24867 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24868 if (SWIG_arg_fail(2)) SWIG_fail;
24869 if (arg1) (arg1)->font = *arg2;
24870
24871 Py_INCREF(Py_None); resultobj = Py_None;
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24879 PyObject *resultobj;
24880 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24881 wxFont *result;
24882 PyObject * obj0 = 0 ;
24883 char *kwnames[] = {
24884 (char *) "self", NULL
24885 };
24886
24887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24889 if (SWIG_arg_fail(1)) SWIG_fail;
24890 result = (wxFont *)& ((arg1)->font);
24891
24892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24893 return resultobj;
24894 fail:
24895 return NULL;
24896 }
24897
24898
24899 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24900 PyObject *resultobj;
24901 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24902 wxColour *arg2 = (wxColour *) 0 ;
24903 PyObject * obj0 = 0 ;
24904 PyObject * obj1 = 0 ;
24905 char *kwnames[] = {
24906 (char *) "self",(char *) "colFg", NULL
24907 };
24908
24909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24911 if (SWIG_arg_fail(1)) SWIG_fail;
24912 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24913 if (SWIG_arg_fail(2)) SWIG_fail;
24914 if (arg1) (arg1)->colFg = *arg2;
24915
24916 Py_INCREF(Py_None); resultobj = Py_None;
24917 return resultobj;
24918 fail:
24919 return NULL;
24920 }
24921
24922
24923 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24924 PyObject *resultobj;
24925 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24926 wxColour *result;
24927 PyObject * obj0 = 0 ;
24928 char *kwnames[] = {
24929 (char *) "self", NULL
24930 };
24931
24932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24934 if (SWIG_arg_fail(1)) SWIG_fail;
24935 result = (wxColour *)& ((arg1)->colFg);
24936
24937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj;
24946 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24947 wxColour *arg2 = (wxColour *) 0 ;
24948 PyObject * obj0 = 0 ;
24949 PyObject * obj1 = 0 ;
24950 char *kwnames[] = {
24951 (char *) "self",(char *) "colBg", NULL
24952 };
24953
24954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24956 if (SWIG_arg_fail(1)) SWIG_fail;
24957 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24958 if (SWIG_arg_fail(2)) SWIG_fail;
24959 if (arg1) (arg1)->colBg = *arg2;
24960
24961 Py_INCREF(Py_None); resultobj = Py_None;
24962 return resultobj;
24963 fail:
24964 return NULL;
24965 }
24966
24967
24968 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24969 PyObject *resultobj;
24970 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24971 wxColour *result;
24972 PyObject * obj0 = 0 ;
24973 char *kwnames[] = {
24974 (char *) "self", NULL
24975 };
24976
24977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24979 if (SWIG_arg_fail(1)) SWIG_fail;
24980 result = (wxColour *)& ((arg1)->colBg);
24981
24982 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24983 return resultobj;
24984 fail:
24985 return NULL;
24986 }
24987
24988
24989 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24990 PyObject *obj;
24991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24992 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24993 Py_INCREF(obj);
24994 return Py_BuildValue((char *)"");
24995 }
24996 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24997 PyObject *resultobj;
24998 wxWindow *arg1 = (wxWindow *) 0 ;
24999 int arg2 = (int) (int)-1 ;
25000 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25001 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25002 wxSize const &arg4_defvalue = wxDefaultSize ;
25003 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25004 long arg5 = (long) 0 ;
25005 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25006 wxString *arg6 = (wxString *) &arg6_defvalue ;
25007 wxWindow *result;
25008 wxPoint temp3 ;
25009 wxSize temp4 ;
25010 bool temp6 = false ;
25011 PyObject * obj0 = 0 ;
25012 PyObject * obj1 = 0 ;
25013 PyObject * obj2 = 0 ;
25014 PyObject * obj3 = 0 ;
25015 PyObject * obj4 = 0 ;
25016 PyObject * obj5 = 0 ;
25017 char *kwnames[] = {
25018 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25019 };
25020
25021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25023 if (SWIG_arg_fail(1)) SWIG_fail;
25024 if (obj1) {
25025 {
25026 arg2 = (int const)(SWIG_As_int(obj1));
25027 if (SWIG_arg_fail(2)) SWIG_fail;
25028 }
25029 }
25030 if (obj2) {
25031 {
25032 arg3 = &temp3;
25033 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25034 }
25035 }
25036 if (obj3) {
25037 {
25038 arg4 = &temp4;
25039 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25040 }
25041 }
25042 if (obj4) {
25043 {
25044 arg5 = (long)(SWIG_As_long(obj4));
25045 if (SWIG_arg_fail(5)) SWIG_fail;
25046 }
25047 }
25048 if (obj5) {
25049 {
25050 arg6 = wxString_in_helper(obj5);
25051 if (arg6 == NULL) SWIG_fail;
25052 temp6 = true;
25053 }
25054 }
25055 {
25056 if (!wxPyCheckForApp()) SWIG_fail;
25057 PyThreadState* __tstate = wxPyBeginAllowThreads();
25058 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25059
25060 wxPyEndAllowThreads(__tstate);
25061 if (PyErr_Occurred()) SWIG_fail;
25062 }
25063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25064 {
25065 if (temp6)
25066 delete arg6;
25067 }
25068 return resultobj;
25069 fail:
25070 {
25071 if (temp6)
25072 delete arg6;
25073 }
25074 return NULL;
25075 }
25076
25077
25078 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25079 PyObject *resultobj;
25080 wxWindow *result;
25081 char *kwnames[] = {
25082 NULL
25083 };
25084
25085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25086 {
25087 if (!wxPyCheckForApp()) SWIG_fail;
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (wxWindow *)new wxWindow();
25090
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25095 return resultobj;
25096 fail:
25097 return NULL;
25098 }
25099
25100
25101 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25102 PyObject *resultobj;
25103 wxWindow *arg1 = (wxWindow *) 0 ;
25104 wxWindow *arg2 = (wxWindow *) 0 ;
25105 int arg3 = (int) (int)-1 ;
25106 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25107 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25108 wxSize const &arg5_defvalue = wxDefaultSize ;
25109 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25110 long arg6 = (long) 0 ;
25111 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25112 wxString *arg7 = (wxString *) &arg7_defvalue ;
25113 bool result;
25114 wxPoint temp4 ;
25115 wxSize temp5 ;
25116 bool temp7 = false ;
25117 PyObject * obj0 = 0 ;
25118 PyObject * obj1 = 0 ;
25119 PyObject * obj2 = 0 ;
25120 PyObject * obj3 = 0 ;
25121 PyObject * obj4 = 0 ;
25122 PyObject * obj5 = 0 ;
25123 PyObject * obj6 = 0 ;
25124 char *kwnames[] = {
25125 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25126 };
25127
25128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25130 if (SWIG_arg_fail(1)) SWIG_fail;
25131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25132 if (SWIG_arg_fail(2)) SWIG_fail;
25133 if (obj2) {
25134 {
25135 arg3 = (int const)(SWIG_As_int(obj2));
25136 if (SWIG_arg_fail(3)) SWIG_fail;
25137 }
25138 }
25139 if (obj3) {
25140 {
25141 arg4 = &temp4;
25142 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25143 }
25144 }
25145 if (obj4) {
25146 {
25147 arg5 = &temp5;
25148 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25149 }
25150 }
25151 if (obj5) {
25152 {
25153 arg6 = (long)(SWIG_As_long(obj5));
25154 if (SWIG_arg_fail(6)) SWIG_fail;
25155 }
25156 }
25157 if (obj6) {
25158 {
25159 arg7 = wxString_in_helper(obj6);
25160 if (arg7 == NULL) SWIG_fail;
25161 temp7 = true;
25162 }
25163 }
25164 {
25165 PyThreadState* __tstate = wxPyBeginAllowThreads();
25166 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25167
25168 wxPyEndAllowThreads(__tstate);
25169 if (PyErr_Occurred()) SWIG_fail;
25170 }
25171 {
25172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25173 }
25174 {
25175 if (temp7)
25176 delete arg7;
25177 }
25178 return resultobj;
25179 fail:
25180 {
25181 if (temp7)
25182 delete arg7;
25183 }
25184 return NULL;
25185 }
25186
25187
25188 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25189 PyObject *resultobj;
25190 wxWindow *arg1 = (wxWindow *) 0 ;
25191 bool arg2 = (bool) false ;
25192 bool result;
25193 PyObject * obj0 = 0 ;
25194 PyObject * obj1 = 0 ;
25195 char *kwnames[] = {
25196 (char *) "self",(char *) "force", NULL
25197 };
25198
25199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25201 if (SWIG_arg_fail(1)) SWIG_fail;
25202 if (obj1) {
25203 {
25204 arg2 = (bool)(SWIG_As_bool(obj1));
25205 if (SWIG_arg_fail(2)) SWIG_fail;
25206 }
25207 }
25208 {
25209 PyThreadState* __tstate = wxPyBeginAllowThreads();
25210 result = (bool)(arg1)->Close(arg2);
25211
25212 wxPyEndAllowThreads(__tstate);
25213 if (PyErr_Occurred()) SWIG_fail;
25214 }
25215 {
25216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25217 }
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj;
25226 wxWindow *arg1 = (wxWindow *) 0 ;
25227 bool result;
25228 PyObject * obj0 = 0 ;
25229 char *kwnames[] = {
25230 (char *) "self", NULL
25231 };
25232
25233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25235 if (SWIG_arg_fail(1)) SWIG_fail;
25236 {
25237 PyThreadState* __tstate = wxPyBeginAllowThreads();
25238 result = (bool)(arg1)->Destroy();
25239
25240 wxPyEndAllowThreads(__tstate);
25241 if (PyErr_Occurred()) SWIG_fail;
25242 }
25243 {
25244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25245 }
25246 return resultobj;
25247 fail:
25248 return NULL;
25249 }
25250
25251
25252 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25253 PyObject *resultobj;
25254 wxWindow *arg1 = (wxWindow *) 0 ;
25255 bool result;
25256 PyObject * obj0 = 0 ;
25257 char *kwnames[] = {
25258 (char *) "self", NULL
25259 };
25260
25261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25263 if (SWIG_arg_fail(1)) SWIG_fail;
25264 {
25265 PyThreadState* __tstate = wxPyBeginAllowThreads();
25266 result = (bool)(arg1)->DestroyChildren();
25267
25268 wxPyEndAllowThreads(__tstate);
25269 if (PyErr_Occurred()) SWIG_fail;
25270 }
25271 {
25272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25273 }
25274 return resultobj;
25275 fail:
25276 return NULL;
25277 }
25278
25279
25280 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25281 PyObject *resultobj;
25282 wxWindow *arg1 = (wxWindow *) 0 ;
25283 bool result;
25284 PyObject * obj0 = 0 ;
25285 char *kwnames[] = {
25286 (char *) "self", NULL
25287 };
25288
25289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25291 if (SWIG_arg_fail(1)) SWIG_fail;
25292 {
25293 PyThreadState* __tstate = wxPyBeginAllowThreads();
25294 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25295
25296 wxPyEndAllowThreads(__tstate);
25297 if (PyErr_Occurred()) SWIG_fail;
25298 }
25299 {
25300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25301 }
25302 return resultobj;
25303 fail:
25304 return NULL;
25305 }
25306
25307
25308 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25309 PyObject *resultobj;
25310 wxWindow *arg1 = (wxWindow *) 0 ;
25311 wxString *arg2 = 0 ;
25312 bool temp2 = false ;
25313 PyObject * obj0 = 0 ;
25314 PyObject * obj1 = 0 ;
25315 char *kwnames[] = {
25316 (char *) "self",(char *) "title", NULL
25317 };
25318
25319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25321 if (SWIG_arg_fail(1)) SWIG_fail;
25322 {
25323 arg2 = wxString_in_helper(obj1);
25324 if (arg2 == NULL) SWIG_fail;
25325 temp2 = true;
25326 }
25327 {
25328 PyThreadState* __tstate = wxPyBeginAllowThreads();
25329 (arg1)->SetTitle((wxString const &)*arg2);
25330
25331 wxPyEndAllowThreads(__tstate);
25332 if (PyErr_Occurred()) SWIG_fail;
25333 }
25334 Py_INCREF(Py_None); resultobj = Py_None;
25335 {
25336 if (temp2)
25337 delete arg2;
25338 }
25339 return resultobj;
25340 fail:
25341 {
25342 if (temp2)
25343 delete arg2;
25344 }
25345 return NULL;
25346 }
25347
25348
25349 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj;
25351 wxWindow *arg1 = (wxWindow *) 0 ;
25352 wxString result;
25353 PyObject * obj0 = 0 ;
25354 char *kwnames[] = {
25355 (char *) "self", NULL
25356 };
25357
25358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25360 if (SWIG_arg_fail(1)) SWIG_fail;
25361 {
25362 PyThreadState* __tstate = wxPyBeginAllowThreads();
25363 result = ((wxWindow const *)arg1)->GetTitle();
25364
25365 wxPyEndAllowThreads(__tstate);
25366 if (PyErr_Occurred()) SWIG_fail;
25367 }
25368 {
25369 #if wxUSE_UNICODE
25370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25371 #else
25372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25373 #endif
25374 }
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25382 PyObject *resultobj;
25383 wxWindow *arg1 = (wxWindow *) 0 ;
25384 wxString *arg2 = 0 ;
25385 bool temp2 = false ;
25386 PyObject * obj0 = 0 ;
25387 PyObject * obj1 = 0 ;
25388 char *kwnames[] = {
25389 (char *) "self",(char *) "label", NULL
25390 };
25391
25392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25394 if (SWIG_arg_fail(1)) SWIG_fail;
25395 {
25396 arg2 = wxString_in_helper(obj1);
25397 if (arg2 == NULL) SWIG_fail;
25398 temp2 = true;
25399 }
25400 {
25401 PyThreadState* __tstate = wxPyBeginAllowThreads();
25402 (arg1)->SetLabel((wxString const &)*arg2);
25403
25404 wxPyEndAllowThreads(__tstate);
25405 if (PyErr_Occurred()) SWIG_fail;
25406 }
25407 Py_INCREF(Py_None); resultobj = Py_None;
25408 {
25409 if (temp2)
25410 delete arg2;
25411 }
25412 return resultobj;
25413 fail:
25414 {
25415 if (temp2)
25416 delete arg2;
25417 }
25418 return NULL;
25419 }
25420
25421
25422 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25423 PyObject *resultobj;
25424 wxWindow *arg1 = (wxWindow *) 0 ;
25425 wxString result;
25426 PyObject * obj0 = 0 ;
25427 char *kwnames[] = {
25428 (char *) "self", NULL
25429 };
25430
25431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25433 if (SWIG_arg_fail(1)) SWIG_fail;
25434 {
25435 PyThreadState* __tstate = wxPyBeginAllowThreads();
25436 result = ((wxWindow const *)arg1)->GetLabel();
25437
25438 wxPyEndAllowThreads(__tstate);
25439 if (PyErr_Occurred()) SWIG_fail;
25440 }
25441 {
25442 #if wxUSE_UNICODE
25443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25444 #else
25445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25446 #endif
25447 }
25448 return resultobj;
25449 fail:
25450 return NULL;
25451 }
25452
25453
25454 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25455 PyObject *resultobj;
25456 wxWindow *arg1 = (wxWindow *) 0 ;
25457 wxString *arg2 = 0 ;
25458 bool temp2 = false ;
25459 PyObject * obj0 = 0 ;
25460 PyObject * obj1 = 0 ;
25461 char *kwnames[] = {
25462 (char *) "self",(char *) "name", NULL
25463 };
25464
25465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25467 if (SWIG_arg_fail(1)) SWIG_fail;
25468 {
25469 arg2 = wxString_in_helper(obj1);
25470 if (arg2 == NULL) SWIG_fail;
25471 temp2 = true;
25472 }
25473 {
25474 PyThreadState* __tstate = wxPyBeginAllowThreads();
25475 (arg1)->SetName((wxString const &)*arg2);
25476
25477 wxPyEndAllowThreads(__tstate);
25478 if (PyErr_Occurred()) SWIG_fail;
25479 }
25480 Py_INCREF(Py_None); resultobj = Py_None;
25481 {
25482 if (temp2)
25483 delete arg2;
25484 }
25485 return resultobj;
25486 fail:
25487 {
25488 if (temp2)
25489 delete arg2;
25490 }
25491 return NULL;
25492 }
25493
25494
25495 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25496 PyObject *resultobj;
25497 wxWindow *arg1 = (wxWindow *) 0 ;
25498 wxString result;
25499 PyObject * obj0 = 0 ;
25500 char *kwnames[] = {
25501 (char *) "self", NULL
25502 };
25503
25504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25506 if (SWIG_arg_fail(1)) SWIG_fail;
25507 {
25508 PyThreadState* __tstate = wxPyBeginAllowThreads();
25509 result = ((wxWindow const *)arg1)->GetName();
25510
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 {
25515 #if wxUSE_UNICODE
25516 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25517 #else
25518 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25519 #endif
25520 }
25521 return resultobj;
25522 fail:
25523 return NULL;
25524 }
25525
25526
25527 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25528 PyObject *resultobj;
25529 wxWindow *arg1 = (wxWindow *) 0 ;
25530 wxWindowVariant arg2 ;
25531 PyObject * obj0 = 0 ;
25532 PyObject * obj1 = 0 ;
25533 char *kwnames[] = {
25534 (char *) "self",(char *) "variant", NULL
25535 };
25536
25537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25539 if (SWIG_arg_fail(1)) SWIG_fail;
25540 {
25541 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25542 if (SWIG_arg_fail(2)) SWIG_fail;
25543 }
25544 {
25545 PyThreadState* __tstate = wxPyBeginAllowThreads();
25546 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25547
25548 wxPyEndAllowThreads(__tstate);
25549 if (PyErr_Occurred()) SWIG_fail;
25550 }
25551 Py_INCREF(Py_None); resultobj = Py_None;
25552 return resultobj;
25553 fail:
25554 return NULL;
25555 }
25556
25557
25558 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25559 PyObject *resultobj;
25560 wxWindow *arg1 = (wxWindow *) 0 ;
25561 wxWindowVariant result;
25562 PyObject * obj0 = 0 ;
25563 char *kwnames[] = {
25564 (char *) "self", NULL
25565 };
25566
25567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25569 if (SWIG_arg_fail(1)) SWIG_fail;
25570 {
25571 PyThreadState* __tstate = wxPyBeginAllowThreads();
25572 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25573
25574 wxPyEndAllowThreads(__tstate);
25575 if (PyErr_Occurred()) SWIG_fail;
25576 }
25577 resultobj = SWIG_From_int((result));
25578 return resultobj;
25579 fail:
25580 return NULL;
25581 }
25582
25583
25584 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25585 PyObject *resultobj;
25586 wxWindow *arg1 = (wxWindow *) 0 ;
25587 int arg2 ;
25588 PyObject * obj0 = 0 ;
25589 PyObject * obj1 = 0 ;
25590 char *kwnames[] = {
25591 (char *) "self",(char *) "winid", NULL
25592 };
25593
25594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25596 if (SWIG_arg_fail(1)) SWIG_fail;
25597 {
25598 arg2 = (int)(SWIG_As_int(obj1));
25599 if (SWIG_arg_fail(2)) SWIG_fail;
25600 }
25601 {
25602 PyThreadState* __tstate = wxPyBeginAllowThreads();
25603 (arg1)->SetId(arg2);
25604
25605 wxPyEndAllowThreads(__tstate);
25606 if (PyErr_Occurred()) SWIG_fail;
25607 }
25608 Py_INCREF(Py_None); resultobj = Py_None;
25609 return resultobj;
25610 fail:
25611 return NULL;
25612 }
25613
25614
25615 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25616 PyObject *resultobj;
25617 wxWindow *arg1 = (wxWindow *) 0 ;
25618 int result;
25619 PyObject * obj0 = 0 ;
25620 char *kwnames[] = {
25621 (char *) "self", NULL
25622 };
25623
25624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25626 if (SWIG_arg_fail(1)) SWIG_fail;
25627 {
25628 PyThreadState* __tstate = wxPyBeginAllowThreads();
25629 result = (int)((wxWindow const *)arg1)->GetId();
25630
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 {
25635 resultobj = SWIG_From_int((int)(result));
25636 }
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25644 PyObject *resultobj;
25645 int result;
25646 char *kwnames[] = {
25647 NULL
25648 };
25649
25650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25651 {
25652 PyThreadState* __tstate = wxPyBeginAllowThreads();
25653 result = (int)wxWindow::NewControlId();
25654
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 {
25659 resultobj = SWIG_From_int((int)(result));
25660 }
25661 return resultobj;
25662 fail:
25663 return NULL;
25664 }
25665
25666
25667 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25668 PyObject *resultobj;
25669 int arg1 ;
25670 int result;
25671 PyObject * obj0 = 0 ;
25672 char *kwnames[] = {
25673 (char *) "winid", NULL
25674 };
25675
25676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25677 {
25678 arg1 = (int)(SWIG_As_int(obj0));
25679 if (SWIG_arg_fail(1)) SWIG_fail;
25680 }
25681 {
25682 PyThreadState* __tstate = wxPyBeginAllowThreads();
25683 result = (int)wxWindow::NextControlId(arg1);
25684
25685 wxPyEndAllowThreads(__tstate);
25686 if (PyErr_Occurred()) SWIG_fail;
25687 }
25688 {
25689 resultobj = SWIG_From_int((int)(result));
25690 }
25691 return resultobj;
25692 fail:
25693 return NULL;
25694 }
25695
25696
25697 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25698 PyObject *resultobj;
25699 int arg1 ;
25700 int result;
25701 PyObject * obj0 = 0 ;
25702 char *kwnames[] = {
25703 (char *) "winid", NULL
25704 };
25705
25706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25707 {
25708 arg1 = (int)(SWIG_As_int(obj0));
25709 if (SWIG_arg_fail(1)) SWIG_fail;
25710 }
25711 {
25712 PyThreadState* __tstate = wxPyBeginAllowThreads();
25713 result = (int)wxWindow::PrevControlId(arg1);
25714
25715 wxPyEndAllowThreads(__tstate);
25716 if (PyErr_Occurred()) SWIG_fail;
25717 }
25718 {
25719 resultobj = SWIG_From_int((int)(result));
25720 }
25721 return resultobj;
25722 fail:
25723 return NULL;
25724 }
25725
25726
25727 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25728 PyObject *resultobj;
25729 wxWindow *arg1 = (wxWindow *) 0 ;
25730 wxSize *arg2 = 0 ;
25731 wxSize temp2 ;
25732 PyObject * obj0 = 0 ;
25733 PyObject * obj1 = 0 ;
25734 char *kwnames[] = {
25735 (char *) "self",(char *) "size", NULL
25736 };
25737
25738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25740 if (SWIG_arg_fail(1)) SWIG_fail;
25741 {
25742 arg2 = &temp2;
25743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25744 }
25745 {
25746 PyThreadState* __tstate = wxPyBeginAllowThreads();
25747 (arg1)->SetSize((wxSize const &)*arg2);
25748
25749 wxPyEndAllowThreads(__tstate);
25750 if (PyErr_Occurred()) SWIG_fail;
25751 }
25752 Py_INCREF(Py_None); resultobj = Py_None;
25753 return resultobj;
25754 fail:
25755 return NULL;
25756 }
25757
25758
25759 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25760 PyObject *resultobj;
25761 wxWindow *arg1 = (wxWindow *) 0 ;
25762 int arg2 ;
25763 int arg3 ;
25764 int arg4 ;
25765 int arg5 ;
25766 int arg6 = (int) wxSIZE_AUTO ;
25767 PyObject * obj0 = 0 ;
25768 PyObject * obj1 = 0 ;
25769 PyObject * obj2 = 0 ;
25770 PyObject * obj3 = 0 ;
25771 PyObject * obj4 = 0 ;
25772 PyObject * obj5 = 0 ;
25773 char *kwnames[] = {
25774 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25775 };
25776
25777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25779 if (SWIG_arg_fail(1)) SWIG_fail;
25780 {
25781 arg2 = (int)(SWIG_As_int(obj1));
25782 if (SWIG_arg_fail(2)) SWIG_fail;
25783 }
25784 {
25785 arg3 = (int)(SWIG_As_int(obj2));
25786 if (SWIG_arg_fail(3)) SWIG_fail;
25787 }
25788 {
25789 arg4 = (int)(SWIG_As_int(obj3));
25790 if (SWIG_arg_fail(4)) SWIG_fail;
25791 }
25792 {
25793 arg5 = (int)(SWIG_As_int(obj4));
25794 if (SWIG_arg_fail(5)) SWIG_fail;
25795 }
25796 if (obj5) {
25797 {
25798 arg6 = (int)(SWIG_As_int(obj5));
25799 if (SWIG_arg_fail(6)) SWIG_fail;
25800 }
25801 }
25802 {
25803 PyThreadState* __tstate = wxPyBeginAllowThreads();
25804 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25805
25806 wxPyEndAllowThreads(__tstate);
25807 if (PyErr_Occurred()) SWIG_fail;
25808 }
25809 Py_INCREF(Py_None); resultobj = Py_None;
25810 return resultobj;
25811 fail:
25812 return NULL;
25813 }
25814
25815
25816 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25817 PyObject *resultobj;
25818 wxWindow *arg1 = (wxWindow *) 0 ;
25819 wxRect *arg2 = 0 ;
25820 int arg3 = (int) wxSIZE_AUTO ;
25821 wxRect temp2 ;
25822 PyObject * obj0 = 0 ;
25823 PyObject * obj1 = 0 ;
25824 PyObject * obj2 = 0 ;
25825 char *kwnames[] = {
25826 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25827 };
25828
25829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25831 if (SWIG_arg_fail(1)) SWIG_fail;
25832 {
25833 arg2 = &temp2;
25834 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25835 }
25836 if (obj2) {
25837 {
25838 arg3 = (int)(SWIG_As_int(obj2));
25839 if (SWIG_arg_fail(3)) SWIG_fail;
25840 }
25841 }
25842 {
25843 PyThreadState* __tstate = wxPyBeginAllowThreads();
25844 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25845
25846 wxPyEndAllowThreads(__tstate);
25847 if (PyErr_Occurred()) SWIG_fail;
25848 }
25849 Py_INCREF(Py_None); resultobj = Py_None;
25850 return resultobj;
25851 fail:
25852 return NULL;
25853 }
25854
25855
25856 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25857 PyObject *resultobj;
25858 wxWindow *arg1 = (wxWindow *) 0 ;
25859 int arg2 ;
25860 int arg3 ;
25861 PyObject * obj0 = 0 ;
25862 PyObject * obj1 = 0 ;
25863 PyObject * obj2 = 0 ;
25864 char *kwnames[] = {
25865 (char *) "self",(char *) "width",(char *) "height", NULL
25866 };
25867
25868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25870 if (SWIG_arg_fail(1)) SWIG_fail;
25871 {
25872 arg2 = (int)(SWIG_As_int(obj1));
25873 if (SWIG_arg_fail(2)) SWIG_fail;
25874 }
25875 {
25876 arg3 = (int)(SWIG_As_int(obj2));
25877 if (SWIG_arg_fail(3)) SWIG_fail;
25878 }
25879 {
25880 PyThreadState* __tstate = wxPyBeginAllowThreads();
25881 (arg1)->SetSize(arg2,arg3);
25882
25883 wxPyEndAllowThreads(__tstate);
25884 if (PyErr_Occurred()) SWIG_fail;
25885 }
25886 Py_INCREF(Py_None); resultobj = Py_None;
25887 return resultobj;
25888 fail:
25889 return NULL;
25890 }
25891
25892
25893 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25894 PyObject *resultobj;
25895 wxWindow *arg1 = (wxWindow *) 0 ;
25896 wxPoint *arg2 = 0 ;
25897 int arg3 = (int) wxSIZE_USE_EXISTING ;
25898 wxPoint temp2 ;
25899 PyObject * obj0 = 0 ;
25900 PyObject * obj1 = 0 ;
25901 PyObject * obj2 = 0 ;
25902 char *kwnames[] = {
25903 (char *) "self",(char *) "pt",(char *) "flags", NULL
25904 };
25905
25906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25908 if (SWIG_arg_fail(1)) SWIG_fail;
25909 {
25910 arg2 = &temp2;
25911 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25912 }
25913 if (obj2) {
25914 {
25915 arg3 = (int)(SWIG_As_int(obj2));
25916 if (SWIG_arg_fail(3)) SWIG_fail;
25917 }
25918 }
25919 {
25920 PyThreadState* __tstate = wxPyBeginAllowThreads();
25921 (arg1)->Move((wxPoint const &)*arg2,arg3);
25922
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 Py_INCREF(Py_None); resultobj = Py_None;
25927 return resultobj;
25928 fail:
25929 return NULL;
25930 }
25931
25932
25933 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25934 PyObject *resultobj;
25935 wxWindow *arg1 = (wxWindow *) 0 ;
25936 int arg2 ;
25937 int arg3 ;
25938 int arg4 = (int) wxSIZE_USE_EXISTING ;
25939 PyObject * obj0 = 0 ;
25940 PyObject * obj1 = 0 ;
25941 PyObject * obj2 = 0 ;
25942 PyObject * obj3 = 0 ;
25943 char *kwnames[] = {
25944 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25945 };
25946
25947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = (int)(SWIG_As_int(obj1));
25952 if (SWIG_arg_fail(2)) SWIG_fail;
25953 }
25954 {
25955 arg3 = (int)(SWIG_As_int(obj2));
25956 if (SWIG_arg_fail(3)) SWIG_fail;
25957 }
25958 if (obj3) {
25959 {
25960 arg4 = (int)(SWIG_As_int(obj3));
25961 if (SWIG_arg_fail(4)) SWIG_fail;
25962 }
25963 }
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 (arg1)->Move(arg2,arg3,arg4);
25967
25968 wxPyEndAllowThreads(__tstate);
25969 if (PyErr_Occurred()) SWIG_fail;
25970 }
25971 Py_INCREF(Py_None); resultobj = Py_None;
25972 return resultobj;
25973 fail:
25974 return NULL;
25975 }
25976
25977
25978 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25979 PyObject *resultobj;
25980 wxWindow *arg1 = (wxWindow *) 0 ;
25981 wxSize const &arg2_defvalue = wxDefaultSize ;
25982 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25983 wxSize temp2 ;
25984 PyObject * obj0 = 0 ;
25985 PyObject * obj1 = 0 ;
25986 char *kwnames[] = {
25987 (char *) "self",(char *) "size", NULL
25988 };
25989
25990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25992 if (SWIG_arg_fail(1)) SWIG_fail;
25993 if (obj1) {
25994 {
25995 arg2 = &temp2;
25996 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25997 }
25998 }
25999 {
26000 PyThreadState* __tstate = wxPyBeginAllowThreads();
26001 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26002
26003 wxPyEndAllowThreads(__tstate);
26004 if (PyErr_Occurred()) SWIG_fail;
26005 }
26006 Py_INCREF(Py_None); resultobj = Py_None;
26007 return resultobj;
26008 fail:
26009 return NULL;
26010 }
26011
26012
26013 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26014 PyObject *resultobj;
26015 wxWindow *arg1 = (wxWindow *) 0 ;
26016 PyObject * obj0 = 0 ;
26017 char *kwnames[] = {
26018 (char *) "self", NULL
26019 };
26020
26021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26023 if (SWIG_arg_fail(1)) SWIG_fail;
26024 {
26025 PyThreadState* __tstate = wxPyBeginAllowThreads();
26026 (arg1)->Raise();
26027
26028 wxPyEndAllowThreads(__tstate);
26029 if (PyErr_Occurred()) SWIG_fail;
26030 }
26031 Py_INCREF(Py_None); resultobj = Py_None;
26032 return resultobj;
26033 fail:
26034 return NULL;
26035 }
26036
26037
26038 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26039 PyObject *resultobj;
26040 wxWindow *arg1 = (wxWindow *) 0 ;
26041 PyObject * obj0 = 0 ;
26042 char *kwnames[] = {
26043 (char *) "self", NULL
26044 };
26045
26046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26048 if (SWIG_arg_fail(1)) SWIG_fail;
26049 {
26050 PyThreadState* __tstate = wxPyBeginAllowThreads();
26051 (arg1)->Lower();
26052
26053 wxPyEndAllowThreads(__tstate);
26054 if (PyErr_Occurred()) SWIG_fail;
26055 }
26056 Py_INCREF(Py_None); resultobj = Py_None;
26057 return resultobj;
26058 fail:
26059 return NULL;
26060 }
26061
26062
26063 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26064 PyObject *resultobj;
26065 wxWindow *arg1 = (wxWindow *) 0 ;
26066 wxSize *arg2 = 0 ;
26067 wxSize temp2 ;
26068 PyObject * obj0 = 0 ;
26069 PyObject * obj1 = 0 ;
26070 char *kwnames[] = {
26071 (char *) "self",(char *) "size", NULL
26072 };
26073
26074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26076 if (SWIG_arg_fail(1)) SWIG_fail;
26077 {
26078 arg2 = &temp2;
26079 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26080 }
26081 {
26082 PyThreadState* __tstate = wxPyBeginAllowThreads();
26083 (arg1)->SetClientSize((wxSize const &)*arg2);
26084
26085 wxPyEndAllowThreads(__tstate);
26086 if (PyErr_Occurred()) SWIG_fail;
26087 }
26088 Py_INCREF(Py_None); resultobj = Py_None;
26089 return resultobj;
26090 fail:
26091 return NULL;
26092 }
26093
26094
26095 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26096 PyObject *resultobj;
26097 wxWindow *arg1 = (wxWindow *) 0 ;
26098 int arg2 ;
26099 int arg3 ;
26100 PyObject * obj0 = 0 ;
26101 PyObject * obj1 = 0 ;
26102 PyObject * obj2 = 0 ;
26103 char *kwnames[] = {
26104 (char *) "self",(char *) "width",(char *) "height", NULL
26105 };
26106
26107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26109 if (SWIG_arg_fail(1)) SWIG_fail;
26110 {
26111 arg2 = (int)(SWIG_As_int(obj1));
26112 if (SWIG_arg_fail(2)) SWIG_fail;
26113 }
26114 {
26115 arg3 = (int)(SWIG_As_int(obj2));
26116 if (SWIG_arg_fail(3)) SWIG_fail;
26117 }
26118 {
26119 PyThreadState* __tstate = wxPyBeginAllowThreads();
26120 (arg1)->SetClientSize(arg2,arg3);
26121
26122 wxPyEndAllowThreads(__tstate);
26123 if (PyErr_Occurred()) SWIG_fail;
26124 }
26125 Py_INCREF(Py_None); resultobj = Py_None;
26126 return resultobj;
26127 fail:
26128 return NULL;
26129 }
26130
26131
26132 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26133 PyObject *resultobj;
26134 wxWindow *arg1 = (wxWindow *) 0 ;
26135 wxRect *arg2 = 0 ;
26136 wxRect temp2 ;
26137 PyObject * obj0 = 0 ;
26138 PyObject * obj1 = 0 ;
26139 char *kwnames[] = {
26140 (char *) "self",(char *) "rect", NULL
26141 };
26142
26143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26145 if (SWIG_arg_fail(1)) SWIG_fail;
26146 {
26147 arg2 = &temp2;
26148 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26149 }
26150 {
26151 PyThreadState* __tstate = wxPyBeginAllowThreads();
26152 (arg1)->SetClientSize((wxRect const &)*arg2);
26153
26154 wxPyEndAllowThreads(__tstate);
26155 if (PyErr_Occurred()) SWIG_fail;
26156 }
26157 Py_INCREF(Py_None); resultobj = Py_None;
26158 return resultobj;
26159 fail:
26160 return NULL;
26161 }
26162
26163
26164 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26165 PyObject *resultobj;
26166 wxWindow *arg1 = (wxWindow *) 0 ;
26167 wxPoint result;
26168 PyObject * obj0 = 0 ;
26169 char *kwnames[] = {
26170 (char *) "self", NULL
26171 };
26172
26173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26175 if (SWIG_arg_fail(1)) SWIG_fail;
26176 {
26177 PyThreadState* __tstate = wxPyBeginAllowThreads();
26178 result = (arg1)->GetPosition();
26179
26180 wxPyEndAllowThreads(__tstate);
26181 if (PyErr_Occurred()) SWIG_fail;
26182 }
26183 {
26184 wxPoint * resultptr;
26185 resultptr = new wxPoint((wxPoint &)(result));
26186 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26187 }
26188 return resultobj;
26189 fail:
26190 return NULL;
26191 }
26192
26193
26194 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26195 PyObject *resultobj;
26196 wxWindow *arg1 = (wxWindow *) 0 ;
26197 int *arg2 = (int *) 0 ;
26198 int *arg3 = (int *) 0 ;
26199 int temp2 ;
26200 int res2 = 0 ;
26201 int temp3 ;
26202 int res3 = 0 ;
26203 PyObject * obj0 = 0 ;
26204 char *kwnames[] = {
26205 (char *) "self", NULL
26206 };
26207
26208 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26209 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26212 if (SWIG_arg_fail(1)) SWIG_fail;
26213 {
26214 PyThreadState* __tstate = wxPyBeginAllowThreads();
26215 (arg1)->GetPosition(arg2,arg3);
26216
26217 wxPyEndAllowThreads(__tstate);
26218 if (PyErr_Occurred()) SWIG_fail;
26219 }
26220 Py_INCREF(Py_None); resultobj = Py_None;
26221 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26222 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26223 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26224 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26225 return resultobj;
26226 fail:
26227 return NULL;
26228 }
26229
26230
26231 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26232 PyObject *resultobj;
26233 wxWindow *arg1 = (wxWindow *) 0 ;
26234 wxSize result;
26235 PyObject * obj0 = 0 ;
26236 char *kwnames[] = {
26237 (char *) "self", NULL
26238 };
26239
26240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26242 if (SWIG_arg_fail(1)) SWIG_fail;
26243 {
26244 PyThreadState* __tstate = wxPyBeginAllowThreads();
26245 result = ((wxWindow const *)arg1)->GetSize();
26246
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 {
26251 wxSize * resultptr;
26252 resultptr = new wxSize((wxSize &)(result));
26253 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26254 }
26255 return resultobj;
26256 fail:
26257 return NULL;
26258 }
26259
26260
26261 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26262 PyObject *resultobj;
26263 wxWindow *arg1 = (wxWindow *) 0 ;
26264 int *arg2 = (int *) 0 ;
26265 int *arg3 = (int *) 0 ;
26266 int temp2 ;
26267 int res2 = 0 ;
26268 int temp3 ;
26269 int res3 = 0 ;
26270 PyObject * obj0 = 0 ;
26271 char *kwnames[] = {
26272 (char *) "self", NULL
26273 };
26274
26275 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26276 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26279 if (SWIG_arg_fail(1)) SWIG_fail;
26280 {
26281 PyThreadState* __tstate = wxPyBeginAllowThreads();
26282 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26283
26284 wxPyEndAllowThreads(__tstate);
26285 if (PyErr_Occurred()) SWIG_fail;
26286 }
26287 Py_INCREF(Py_None); resultobj = Py_None;
26288 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26289 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26290 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26291 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26292 return resultobj;
26293 fail:
26294 return NULL;
26295 }
26296
26297
26298 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26299 PyObject *resultobj;
26300 wxWindow *arg1 = (wxWindow *) 0 ;
26301 wxRect result;
26302 PyObject * obj0 = 0 ;
26303 char *kwnames[] = {
26304 (char *) "self", NULL
26305 };
26306
26307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26309 if (SWIG_arg_fail(1)) SWIG_fail;
26310 {
26311 PyThreadState* __tstate = wxPyBeginAllowThreads();
26312 result = ((wxWindow const *)arg1)->GetRect();
26313
26314 wxPyEndAllowThreads(__tstate);
26315 if (PyErr_Occurred()) SWIG_fail;
26316 }
26317 {
26318 wxRect * resultptr;
26319 resultptr = new wxRect((wxRect &)(result));
26320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26321 }
26322 return resultobj;
26323 fail:
26324 return NULL;
26325 }
26326
26327
26328 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26329 PyObject *resultobj;
26330 wxWindow *arg1 = (wxWindow *) 0 ;
26331 wxSize result;
26332 PyObject * obj0 = 0 ;
26333 char *kwnames[] = {
26334 (char *) "self", NULL
26335 };
26336
26337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26339 if (SWIG_arg_fail(1)) SWIG_fail;
26340 {
26341 PyThreadState* __tstate = wxPyBeginAllowThreads();
26342 result = ((wxWindow const *)arg1)->GetClientSize();
26343
26344 wxPyEndAllowThreads(__tstate);
26345 if (PyErr_Occurred()) SWIG_fail;
26346 }
26347 {
26348 wxSize * resultptr;
26349 resultptr = new wxSize((wxSize &)(result));
26350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26351 }
26352 return resultobj;
26353 fail:
26354 return NULL;
26355 }
26356
26357
26358 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26359 PyObject *resultobj;
26360 wxWindow *arg1 = (wxWindow *) 0 ;
26361 int *arg2 = (int *) 0 ;
26362 int *arg3 = (int *) 0 ;
26363 int temp2 ;
26364 int res2 = 0 ;
26365 int temp3 ;
26366 int res3 = 0 ;
26367 PyObject * obj0 = 0 ;
26368 char *kwnames[] = {
26369 (char *) "self", NULL
26370 };
26371
26372 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26373 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26376 if (SWIG_arg_fail(1)) SWIG_fail;
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26380
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 Py_INCREF(Py_None); resultobj = Py_None;
26385 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26386 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26387 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26388 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26389 return resultobj;
26390 fail:
26391 return NULL;
26392 }
26393
26394
26395 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26396 PyObject *resultobj;
26397 wxWindow *arg1 = (wxWindow *) 0 ;
26398 wxPoint result;
26399 PyObject * obj0 = 0 ;
26400 char *kwnames[] = {
26401 (char *) "self", NULL
26402 };
26403
26404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26406 if (SWIG_arg_fail(1)) SWIG_fail;
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26410
26411 wxPyEndAllowThreads(__tstate);
26412 if (PyErr_Occurred()) SWIG_fail;
26413 }
26414 {
26415 wxPoint * resultptr;
26416 resultptr = new wxPoint((wxPoint &)(result));
26417 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26418 }
26419 return resultobj;
26420 fail:
26421 return NULL;
26422 }
26423
26424
26425 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26426 PyObject *resultobj;
26427 wxWindow *arg1 = (wxWindow *) 0 ;
26428 wxRect result;
26429 PyObject * obj0 = 0 ;
26430 char *kwnames[] = {
26431 (char *) "self", NULL
26432 };
26433
26434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26436 if (SWIG_arg_fail(1)) SWIG_fail;
26437 {
26438 PyThreadState* __tstate = wxPyBeginAllowThreads();
26439 result = ((wxWindow const *)arg1)->GetClientRect();
26440
26441 wxPyEndAllowThreads(__tstate);
26442 if (PyErr_Occurred()) SWIG_fail;
26443 }
26444 {
26445 wxRect * resultptr;
26446 resultptr = new wxRect((wxRect &)(result));
26447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26448 }
26449 return resultobj;
26450 fail:
26451 return NULL;
26452 }
26453
26454
26455 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26456 PyObject *resultobj;
26457 wxWindow *arg1 = (wxWindow *) 0 ;
26458 wxSize result;
26459 PyObject * obj0 = 0 ;
26460 char *kwnames[] = {
26461 (char *) "self", NULL
26462 };
26463
26464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26466 if (SWIG_arg_fail(1)) SWIG_fail;
26467 {
26468 PyThreadState* __tstate = wxPyBeginAllowThreads();
26469 result = ((wxWindow const *)arg1)->GetBestSize();
26470
26471 wxPyEndAllowThreads(__tstate);
26472 if (PyErr_Occurred()) SWIG_fail;
26473 }
26474 {
26475 wxSize * resultptr;
26476 resultptr = new wxSize((wxSize &)(result));
26477 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26478 }
26479 return resultobj;
26480 fail:
26481 return NULL;
26482 }
26483
26484
26485 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26486 PyObject *resultobj;
26487 wxWindow *arg1 = (wxWindow *) 0 ;
26488 int *arg2 = (int *) 0 ;
26489 int *arg3 = (int *) 0 ;
26490 int temp2 ;
26491 int res2 = 0 ;
26492 int temp3 ;
26493 int res3 = 0 ;
26494 PyObject * obj0 = 0 ;
26495 char *kwnames[] = {
26496 (char *) "self", NULL
26497 };
26498
26499 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26500 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26503 if (SWIG_arg_fail(1)) SWIG_fail;
26504 {
26505 PyThreadState* __tstate = wxPyBeginAllowThreads();
26506 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26507
26508 wxPyEndAllowThreads(__tstate);
26509 if (PyErr_Occurred()) SWIG_fail;
26510 }
26511 Py_INCREF(Py_None); resultobj = Py_None;
26512 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26513 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26514 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26515 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26516 return resultobj;
26517 fail:
26518 return NULL;
26519 }
26520
26521
26522 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26523 PyObject *resultobj;
26524 wxWindow *arg1 = (wxWindow *) 0 ;
26525 PyObject * obj0 = 0 ;
26526 char *kwnames[] = {
26527 (char *) "self", NULL
26528 };
26529
26530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26532 if (SWIG_arg_fail(1)) SWIG_fail;
26533 {
26534 PyThreadState* __tstate = wxPyBeginAllowThreads();
26535 (arg1)->InvalidateBestSize();
26536
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 Py_INCREF(Py_None); resultobj = Py_None;
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26548 PyObject *resultobj;
26549 wxWindow *arg1 = (wxWindow *) 0 ;
26550 wxSize result;
26551 PyObject * obj0 = 0 ;
26552 char *kwnames[] = {
26553 (char *) "self", NULL
26554 };
26555
26556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26558 if (SWIG_arg_fail(1)) SWIG_fail;
26559 {
26560 PyThreadState* __tstate = wxPyBeginAllowThreads();
26561 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26562
26563 wxPyEndAllowThreads(__tstate);
26564 if (PyErr_Occurred()) SWIG_fail;
26565 }
26566 {
26567 wxSize * resultptr;
26568 resultptr = new wxSize((wxSize &)(result));
26569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26570 }
26571 return resultobj;
26572 fail:
26573 return NULL;
26574 }
26575
26576
26577 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26578 PyObject *resultobj;
26579 wxWindow *arg1 = (wxWindow *) 0 ;
26580 wxSize result;
26581 PyObject * obj0 = 0 ;
26582 char *kwnames[] = {
26583 (char *) "self", NULL
26584 };
26585
26586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
26591 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26592
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 {
26597 wxSize * resultptr;
26598 resultptr = new wxSize((wxSize &)(result));
26599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26600 }
26601 return resultobj;
26602 fail:
26603 return NULL;
26604 }
26605
26606
26607 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26608 PyObject *resultobj;
26609 wxWindow *arg1 = (wxWindow *) 0 ;
26610 int arg2 = (int) wxBOTH ;
26611 PyObject * obj0 = 0 ;
26612 PyObject * obj1 = 0 ;
26613 char *kwnames[] = {
26614 (char *) "self",(char *) "direction", NULL
26615 };
26616
26617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26619 if (SWIG_arg_fail(1)) SWIG_fail;
26620 if (obj1) {
26621 {
26622 arg2 = (int)(SWIG_As_int(obj1));
26623 if (SWIG_arg_fail(2)) SWIG_fail;
26624 }
26625 }
26626 {
26627 PyThreadState* __tstate = wxPyBeginAllowThreads();
26628 (arg1)->Center(arg2);
26629
26630 wxPyEndAllowThreads(__tstate);
26631 if (PyErr_Occurred()) SWIG_fail;
26632 }
26633 Py_INCREF(Py_None); resultobj = Py_None;
26634 return resultobj;
26635 fail:
26636 return NULL;
26637 }
26638
26639
26640 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26641 PyObject *resultobj;
26642 wxWindow *arg1 = (wxWindow *) 0 ;
26643 int arg2 = (int) wxBOTH ;
26644 PyObject * obj0 = 0 ;
26645 PyObject * obj1 = 0 ;
26646 char *kwnames[] = {
26647 (char *) "self",(char *) "dir", NULL
26648 };
26649
26650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26652 if (SWIG_arg_fail(1)) SWIG_fail;
26653 if (obj1) {
26654 {
26655 arg2 = (int)(SWIG_As_int(obj1));
26656 if (SWIG_arg_fail(2)) SWIG_fail;
26657 }
26658 }
26659 {
26660 PyThreadState* __tstate = wxPyBeginAllowThreads();
26661 (arg1)->CenterOnScreen(arg2);
26662
26663 wxPyEndAllowThreads(__tstate);
26664 if (PyErr_Occurred()) SWIG_fail;
26665 }
26666 Py_INCREF(Py_None); resultobj = Py_None;
26667 return resultobj;
26668 fail:
26669 return NULL;
26670 }
26671
26672
26673 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26674 PyObject *resultobj;
26675 wxWindow *arg1 = (wxWindow *) 0 ;
26676 int arg2 = (int) wxBOTH ;
26677 PyObject * obj0 = 0 ;
26678 PyObject * obj1 = 0 ;
26679 char *kwnames[] = {
26680 (char *) "self",(char *) "dir", NULL
26681 };
26682
26683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26685 if (SWIG_arg_fail(1)) SWIG_fail;
26686 if (obj1) {
26687 {
26688 arg2 = (int)(SWIG_As_int(obj1));
26689 if (SWIG_arg_fail(2)) SWIG_fail;
26690 }
26691 }
26692 {
26693 PyThreadState* __tstate = wxPyBeginAllowThreads();
26694 (arg1)->CenterOnParent(arg2);
26695
26696 wxPyEndAllowThreads(__tstate);
26697 if (PyErr_Occurred()) SWIG_fail;
26698 }
26699 Py_INCREF(Py_None); resultobj = Py_None;
26700 return resultobj;
26701 fail:
26702 return NULL;
26703 }
26704
26705
26706 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26707 PyObject *resultobj;
26708 wxWindow *arg1 = (wxWindow *) 0 ;
26709 PyObject * obj0 = 0 ;
26710 char *kwnames[] = {
26711 (char *) "self", NULL
26712 };
26713
26714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26716 if (SWIG_arg_fail(1)) SWIG_fail;
26717 {
26718 PyThreadState* __tstate = wxPyBeginAllowThreads();
26719 (arg1)->Fit();
26720
26721 wxPyEndAllowThreads(__tstate);
26722 if (PyErr_Occurred()) SWIG_fail;
26723 }
26724 Py_INCREF(Py_None); resultobj = Py_None;
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26732 PyObject *resultobj;
26733 wxWindow *arg1 = (wxWindow *) 0 ;
26734 PyObject * obj0 = 0 ;
26735 char *kwnames[] = {
26736 (char *) "self", NULL
26737 };
26738
26739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26741 if (SWIG_arg_fail(1)) SWIG_fail;
26742 {
26743 PyThreadState* __tstate = wxPyBeginAllowThreads();
26744 (arg1)->FitInside();
26745
26746 wxPyEndAllowThreads(__tstate);
26747 if (PyErr_Occurred()) SWIG_fail;
26748 }
26749 Py_INCREF(Py_None); resultobj = Py_None;
26750 return resultobj;
26751 fail:
26752 return NULL;
26753 }
26754
26755
26756 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26757 PyObject *resultobj;
26758 wxWindow *arg1 = (wxWindow *) 0 ;
26759 int arg2 ;
26760 int arg3 ;
26761 int arg4 = (int) -1 ;
26762 int arg5 = (int) -1 ;
26763 int arg6 = (int) -1 ;
26764 int arg7 = (int) -1 ;
26765 PyObject * obj0 = 0 ;
26766 PyObject * obj1 = 0 ;
26767 PyObject * obj2 = 0 ;
26768 PyObject * obj3 = 0 ;
26769 PyObject * obj4 = 0 ;
26770 PyObject * obj5 = 0 ;
26771 PyObject * obj6 = 0 ;
26772 char *kwnames[] = {
26773 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26774 };
26775
26776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26778 if (SWIG_arg_fail(1)) SWIG_fail;
26779 {
26780 arg2 = (int)(SWIG_As_int(obj1));
26781 if (SWIG_arg_fail(2)) SWIG_fail;
26782 }
26783 {
26784 arg3 = (int)(SWIG_As_int(obj2));
26785 if (SWIG_arg_fail(3)) SWIG_fail;
26786 }
26787 if (obj3) {
26788 {
26789 arg4 = (int)(SWIG_As_int(obj3));
26790 if (SWIG_arg_fail(4)) SWIG_fail;
26791 }
26792 }
26793 if (obj4) {
26794 {
26795 arg5 = (int)(SWIG_As_int(obj4));
26796 if (SWIG_arg_fail(5)) SWIG_fail;
26797 }
26798 }
26799 if (obj5) {
26800 {
26801 arg6 = (int)(SWIG_As_int(obj5));
26802 if (SWIG_arg_fail(6)) SWIG_fail;
26803 }
26804 }
26805 if (obj6) {
26806 {
26807 arg7 = (int)(SWIG_As_int(obj6));
26808 if (SWIG_arg_fail(7)) SWIG_fail;
26809 }
26810 }
26811 {
26812 PyThreadState* __tstate = wxPyBeginAllowThreads();
26813 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26814
26815 wxPyEndAllowThreads(__tstate);
26816 if (PyErr_Occurred()) SWIG_fail;
26817 }
26818 Py_INCREF(Py_None); resultobj = Py_None;
26819 return resultobj;
26820 fail:
26821 return NULL;
26822 }
26823
26824
26825 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26826 PyObject *resultobj;
26827 wxWindow *arg1 = (wxWindow *) 0 ;
26828 wxSize *arg2 = 0 ;
26829 wxSize const &arg3_defvalue = wxDefaultSize ;
26830 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26831 wxSize const &arg4_defvalue = wxDefaultSize ;
26832 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26833 wxSize temp2 ;
26834 wxSize temp3 ;
26835 wxSize temp4 ;
26836 PyObject * obj0 = 0 ;
26837 PyObject * obj1 = 0 ;
26838 PyObject * obj2 = 0 ;
26839 PyObject * obj3 = 0 ;
26840 char *kwnames[] = {
26841 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26842 };
26843
26844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26846 if (SWIG_arg_fail(1)) SWIG_fail;
26847 {
26848 arg2 = &temp2;
26849 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26850 }
26851 if (obj2) {
26852 {
26853 arg3 = &temp3;
26854 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26855 }
26856 }
26857 if (obj3) {
26858 {
26859 arg4 = &temp4;
26860 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26861 }
26862 }
26863 {
26864 PyThreadState* __tstate = wxPyBeginAllowThreads();
26865 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26866
26867 wxPyEndAllowThreads(__tstate);
26868 if (PyErr_Occurred()) SWIG_fail;
26869 }
26870 Py_INCREF(Py_None); resultobj = Py_None;
26871 return resultobj;
26872 fail:
26873 return NULL;
26874 }
26875
26876
26877 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26878 PyObject *resultobj;
26879 wxWindow *arg1 = (wxWindow *) 0 ;
26880 int arg2 ;
26881 int arg3 ;
26882 int arg4 = (int) -1 ;
26883 int arg5 = (int) -1 ;
26884 PyObject * obj0 = 0 ;
26885 PyObject * obj1 = 0 ;
26886 PyObject * obj2 = 0 ;
26887 PyObject * obj3 = 0 ;
26888 PyObject * obj4 = 0 ;
26889 char *kwnames[] = {
26890 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26891 };
26892
26893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26895 if (SWIG_arg_fail(1)) SWIG_fail;
26896 {
26897 arg2 = (int)(SWIG_As_int(obj1));
26898 if (SWIG_arg_fail(2)) SWIG_fail;
26899 }
26900 {
26901 arg3 = (int)(SWIG_As_int(obj2));
26902 if (SWIG_arg_fail(3)) SWIG_fail;
26903 }
26904 if (obj3) {
26905 {
26906 arg4 = (int)(SWIG_As_int(obj3));
26907 if (SWIG_arg_fail(4)) SWIG_fail;
26908 }
26909 }
26910 if (obj4) {
26911 {
26912 arg5 = (int)(SWIG_As_int(obj4));
26913 if (SWIG_arg_fail(5)) SWIG_fail;
26914 }
26915 }
26916 {
26917 PyThreadState* __tstate = wxPyBeginAllowThreads();
26918 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26919
26920 wxPyEndAllowThreads(__tstate);
26921 if (PyErr_Occurred()) SWIG_fail;
26922 }
26923 Py_INCREF(Py_None); resultobj = Py_None;
26924 return resultobj;
26925 fail:
26926 return NULL;
26927 }
26928
26929
26930 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26931 PyObject *resultobj;
26932 wxWindow *arg1 = (wxWindow *) 0 ;
26933 wxSize *arg2 = 0 ;
26934 wxSize const &arg3_defvalue = wxDefaultSize ;
26935 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26936 wxSize temp2 ;
26937 wxSize temp3 ;
26938 PyObject * obj0 = 0 ;
26939 PyObject * obj1 = 0 ;
26940 PyObject * obj2 = 0 ;
26941 char *kwnames[] = {
26942 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26943 };
26944
26945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26947 if (SWIG_arg_fail(1)) SWIG_fail;
26948 {
26949 arg2 = &temp2;
26950 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26951 }
26952 if (obj2) {
26953 {
26954 arg3 = &temp3;
26955 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26956 }
26957 }
26958 {
26959 PyThreadState* __tstate = wxPyBeginAllowThreads();
26960 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26961
26962 wxPyEndAllowThreads(__tstate);
26963 if (PyErr_Occurred()) SWIG_fail;
26964 }
26965 Py_INCREF(Py_None); resultobj = Py_None;
26966 return resultobj;
26967 fail:
26968 return NULL;
26969 }
26970
26971
26972 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26973 PyObject *resultobj;
26974 wxWindow *arg1 = (wxWindow *) 0 ;
26975 wxSize result;
26976 PyObject * obj0 = 0 ;
26977 char *kwnames[] = {
26978 (char *) "self", NULL
26979 };
26980
26981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26983 if (SWIG_arg_fail(1)) SWIG_fail;
26984 {
26985 PyThreadState* __tstate = wxPyBeginAllowThreads();
26986 result = ((wxWindow const *)arg1)->GetMaxSize();
26987
26988 wxPyEndAllowThreads(__tstate);
26989 if (PyErr_Occurred()) SWIG_fail;
26990 }
26991 {
26992 wxSize * resultptr;
26993 resultptr = new wxSize((wxSize &)(result));
26994 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26995 }
26996 return resultobj;
26997 fail:
26998 return NULL;
26999 }
27000
27001
27002 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27003 PyObject *resultobj;
27004 wxWindow *arg1 = (wxWindow *) 0 ;
27005 wxSize result;
27006 PyObject * obj0 = 0 ;
27007 char *kwnames[] = {
27008 (char *) "self", NULL
27009 };
27010
27011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27013 if (SWIG_arg_fail(1)) SWIG_fail;
27014 {
27015 PyThreadState* __tstate = wxPyBeginAllowThreads();
27016 result = ((wxWindow const *)arg1)->GetMinSize();
27017
27018 wxPyEndAllowThreads(__tstate);
27019 if (PyErr_Occurred()) SWIG_fail;
27020 }
27021 {
27022 wxSize * resultptr;
27023 resultptr = new wxSize((wxSize &)(result));
27024 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27025 }
27026 return resultobj;
27027 fail:
27028 return NULL;
27029 }
27030
27031
27032 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27033 PyObject *resultobj;
27034 wxWindow *arg1 = (wxWindow *) 0 ;
27035 wxSize *arg2 = 0 ;
27036 wxSize temp2 ;
27037 PyObject * obj0 = 0 ;
27038 PyObject * obj1 = 0 ;
27039 char *kwnames[] = {
27040 (char *) "self",(char *) "minSize", NULL
27041 };
27042
27043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27045 if (SWIG_arg_fail(1)) SWIG_fail;
27046 {
27047 arg2 = &temp2;
27048 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27049 }
27050 {
27051 PyThreadState* __tstate = wxPyBeginAllowThreads();
27052 (arg1)->SetMinSize((wxSize const &)*arg2);
27053
27054 wxPyEndAllowThreads(__tstate);
27055 if (PyErr_Occurred()) SWIG_fail;
27056 }
27057 Py_INCREF(Py_None); resultobj = Py_None;
27058 return resultobj;
27059 fail:
27060 return NULL;
27061 }
27062
27063
27064 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27065 PyObject *resultobj;
27066 wxWindow *arg1 = (wxWindow *) 0 ;
27067 wxSize *arg2 = 0 ;
27068 wxSize temp2 ;
27069 PyObject * obj0 = 0 ;
27070 PyObject * obj1 = 0 ;
27071 char *kwnames[] = {
27072 (char *) "self",(char *) "maxSize", NULL
27073 };
27074
27075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27077 if (SWIG_arg_fail(1)) SWIG_fail;
27078 {
27079 arg2 = &temp2;
27080 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27081 }
27082 {
27083 PyThreadState* __tstate = wxPyBeginAllowThreads();
27084 (arg1)->SetMaxSize((wxSize const &)*arg2);
27085
27086 wxPyEndAllowThreads(__tstate);
27087 if (PyErr_Occurred()) SWIG_fail;
27088 }
27089 Py_INCREF(Py_None); resultobj = Py_None;
27090 return resultobj;
27091 fail:
27092 return NULL;
27093 }
27094
27095
27096 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj;
27098 wxWindow *arg1 = (wxWindow *) 0 ;
27099 int result;
27100 PyObject * obj0 = 0 ;
27101 char *kwnames[] = {
27102 (char *) "self", NULL
27103 };
27104
27105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27107 if (SWIG_arg_fail(1)) SWIG_fail;
27108 {
27109 PyThreadState* __tstate = wxPyBeginAllowThreads();
27110 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27111
27112 wxPyEndAllowThreads(__tstate);
27113 if (PyErr_Occurred()) SWIG_fail;
27114 }
27115 {
27116 resultobj = SWIG_From_int((int)(result));
27117 }
27118 return resultobj;
27119 fail:
27120 return NULL;
27121 }
27122
27123
27124 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27125 PyObject *resultobj;
27126 wxWindow *arg1 = (wxWindow *) 0 ;
27127 int result;
27128 PyObject * obj0 = 0 ;
27129 char *kwnames[] = {
27130 (char *) "self", NULL
27131 };
27132
27133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27135 if (SWIG_arg_fail(1)) SWIG_fail;
27136 {
27137 PyThreadState* __tstate = wxPyBeginAllowThreads();
27138 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27139
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 {
27144 resultobj = SWIG_From_int((int)(result));
27145 }
27146 return resultobj;
27147 fail:
27148 return NULL;
27149 }
27150
27151
27152 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27153 PyObject *resultobj;
27154 wxWindow *arg1 = (wxWindow *) 0 ;
27155 int result;
27156 PyObject * obj0 = 0 ;
27157 char *kwnames[] = {
27158 (char *) "self", NULL
27159 };
27160
27161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27163 if (SWIG_arg_fail(1)) SWIG_fail;
27164 {
27165 PyThreadState* __tstate = wxPyBeginAllowThreads();
27166 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27167
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 {
27172 resultobj = SWIG_From_int((int)(result));
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj;
27182 wxWindow *arg1 = (wxWindow *) 0 ;
27183 int result;
27184 PyObject * obj0 = 0 ;
27185 char *kwnames[] = {
27186 (char *) "self", NULL
27187 };
27188
27189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27191 if (SWIG_arg_fail(1)) SWIG_fail;
27192 {
27193 PyThreadState* __tstate = wxPyBeginAllowThreads();
27194 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27195
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 {
27200 resultobj = SWIG_From_int((int)(result));
27201 }
27202 return resultobj;
27203 fail:
27204 return NULL;
27205 }
27206
27207
27208 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27209 PyObject *resultobj;
27210 wxWindow *arg1 = (wxWindow *) 0 ;
27211 wxSize *arg2 = 0 ;
27212 wxSize temp2 ;
27213 PyObject * obj0 = 0 ;
27214 PyObject * obj1 = 0 ;
27215 char *kwnames[] = {
27216 (char *) "self",(char *) "size", NULL
27217 };
27218
27219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27221 if (SWIG_arg_fail(1)) SWIG_fail;
27222 {
27223 arg2 = &temp2;
27224 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27225 }
27226 {
27227 PyThreadState* __tstate = wxPyBeginAllowThreads();
27228 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27229
27230 wxPyEndAllowThreads(__tstate);
27231 if (PyErr_Occurred()) SWIG_fail;
27232 }
27233 Py_INCREF(Py_None); resultobj = Py_None;
27234 return resultobj;
27235 fail:
27236 return NULL;
27237 }
27238
27239
27240 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27241 PyObject *resultobj;
27242 wxWindow *arg1 = (wxWindow *) 0 ;
27243 int arg2 ;
27244 int arg3 ;
27245 PyObject * obj0 = 0 ;
27246 PyObject * obj1 = 0 ;
27247 PyObject * obj2 = 0 ;
27248 char *kwnames[] = {
27249 (char *) "self",(char *) "w",(char *) "h", NULL
27250 };
27251
27252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27254 if (SWIG_arg_fail(1)) SWIG_fail;
27255 {
27256 arg2 = (int)(SWIG_As_int(obj1));
27257 if (SWIG_arg_fail(2)) SWIG_fail;
27258 }
27259 {
27260 arg3 = (int)(SWIG_As_int(obj2));
27261 if (SWIG_arg_fail(3)) SWIG_fail;
27262 }
27263 {
27264 PyThreadState* __tstate = wxPyBeginAllowThreads();
27265 (arg1)->SetVirtualSize(arg2,arg3);
27266
27267 wxPyEndAllowThreads(__tstate);
27268 if (PyErr_Occurred()) SWIG_fail;
27269 }
27270 Py_INCREF(Py_None); resultobj = Py_None;
27271 return resultobj;
27272 fail:
27273 return NULL;
27274 }
27275
27276
27277 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27278 PyObject *resultobj;
27279 wxWindow *arg1 = (wxWindow *) 0 ;
27280 wxSize result;
27281 PyObject * obj0 = 0 ;
27282 char *kwnames[] = {
27283 (char *) "self", NULL
27284 };
27285
27286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27288 if (SWIG_arg_fail(1)) SWIG_fail;
27289 {
27290 PyThreadState* __tstate = wxPyBeginAllowThreads();
27291 result = ((wxWindow const *)arg1)->GetVirtualSize();
27292
27293 wxPyEndAllowThreads(__tstate);
27294 if (PyErr_Occurred()) SWIG_fail;
27295 }
27296 {
27297 wxSize * resultptr;
27298 resultptr = new wxSize((wxSize &)(result));
27299 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27300 }
27301 return resultobj;
27302 fail:
27303 return NULL;
27304 }
27305
27306
27307 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27308 PyObject *resultobj;
27309 wxWindow *arg1 = (wxWindow *) 0 ;
27310 int *arg2 = (int *) 0 ;
27311 int *arg3 = (int *) 0 ;
27312 int temp2 ;
27313 int res2 = 0 ;
27314 int temp3 ;
27315 int res3 = 0 ;
27316 PyObject * obj0 = 0 ;
27317 char *kwnames[] = {
27318 (char *) "self", NULL
27319 };
27320
27321 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27322 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27325 if (SWIG_arg_fail(1)) SWIG_fail;
27326 {
27327 PyThreadState* __tstate = wxPyBeginAllowThreads();
27328 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27329
27330 wxPyEndAllowThreads(__tstate);
27331 if (PyErr_Occurred()) SWIG_fail;
27332 }
27333 Py_INCREF(Py_None); resultobj = Py_None;
27334 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27335 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27336 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27337 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27338 return resultobj;
27339 fail:
27340 return NULL;
27341 }
27342
27343
27344 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27345 PyObject *resultobj;
27346 wxWindow *arg1 = (wxWindow *) 0 ;
27347 wxSize result;
27348 PyObject * obj0 = 0 ;
27349 char *kwnames[] = {
27350 (char *) "self", NULL
27351 };
27352
27353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27355 if (SWIG_arg_fail(1)) SWIG_fail;
27356 {
27357 PyThreadState* __tstate = wxPyBeginAllowThreads();
27358 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27359
27360 wxPyEndAllowThreads(__tstate);
27361 if (PyErr_Occurred()) SWIG_fail;
27362 }
27363 {
27364 wxSize * resultptr;
27365 resultptr = new wxSize((wxSize &)(result));
27366 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27367 }
27368 return resultobj;
27369 fail:
27370 return NULL;
27371 }
27372
27373
27374 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27375 PyObject *resultobj;
27376 wxWindow *arg1 = (wxWindow *) 0 ;
27377 bool arg2 = (bool) true ;
27378 bool result;
27379 PyObject * obj0 = 0 ;
27380 PyObject * obj1 = 0 ;
27381 char *kwnames[] = {
27382 (char *) "self",(char *) "show", NULL
27383 };
27384
27385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27387 if (SWIG_arg_fail(1)) SWIG_fail;
27388 if (obj1) {
27389 {
27390 arg2 = (bool)(SWIG_As_bool(obj1));
27391 if (SWIG_arg_fail(2)) SWIG_fail;
27392 }
27393 }
27394 {
27395 PyThreadState* __tstate = wxPyBeginAllowThreads();
27396 result = (bool)(arg1)->Show(arg2);
27397
27398 wxPyEndAllowThreads(__tstate);
27399 if (PyErr_Occurred()) SWIG_fail;
27400 }
27401 {
27402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27403 }
27404 return resultobj;
27405 fail:
27406 return NULL;
27407 }
27408
27409
27410 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27411 PyObject *resultobj;
27412 wxWindow *arg1 = (wxWindow *) 0 ;
27413 bool result;
27414 PyObject * obj0 = 0 ;
27415 char *kwnames[] = {
27416 (char *) "self", NULL
27417 };
27418
27419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27421 if (SWIG_arg_fail(1)) SWIG_fail;
27422 {
27423 PyThreadState* __tstate = wxPyBeginAllowThreads();
27424 result = (bool)(arg1)->Hide();
27425
27426 wxPyEndAllowThreads(__tstate);
27427 if (PyErr_Occurred()) SWIG_fail;
27428 }
27429 {
27430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27431 }
27432 return resultobj;
27433 fail:
27434 return NULL;
27435 }
27436
27437
27438 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27439 PyObject *resultobj;
27440 wxWindow *arg1 = (wxWindow *) 0 ;
27441 bool arg2 = (bool) true ;
27442 bool result;
27443 PyObject * obj0 = 0 ;
27444 PyObject * obj1 = 0 ;
27445 char *kwnames[] = {
27446 (char *) "self",(char *) "enable", NULL
27447 };
27448
27449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27451 if (SWIG_arg_fail(1)) SWIG_fail;
27452 if (obj1) {
27453 {
27454 arg2 = (bool)(SWIG_As_bool(obj1));
27455 if (SWIG_arg_fail(2)) SWIG_fail;
27456 }
27457 }
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = (bool)(arg1)->Enable(arg2);
27461
27462 wxPyEndAllowThreads(__tstate);
27463 if (PyErr_Occurred()) SWIG_fail;
27464 }
27465 {
27466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27467 }
27468 return resultobj;
27469 fail:
27470 return NULL;
27471 }
27472
27473
27474 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27475 PyObject *resultobj;
27476 wxWindow *arg1 = (wxWindow *) 0 ;
27477 bool result;
27478 PyObject * obj0 = 0 ;
27479 char *kwnames[] = {
27480 (char *) "self", NULL
27481 };
27482
27483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27485 if (SWIG_arg_fail(1)) SWIG_fail;
27486 {
27487 PyThreadState* __tstate = wxPyBeginAllowThreads();
27488 result = (bool)(arg1)->Disable();
27489
27490 wxPyEndAllowThreads(__tstate);
27491 if (PyErr_Occurred()) SWIG_fail;
27492 }
27493 {
27494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27495 }
27496 return resultobj;
27497 fail:
27498 return NULL;
27499 }
27500
27501
27502 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27503 PyObject *resultobj;
27504 wxWindow *arg1 = (wxWindow *) 0 ;
27505 bool result;
27506 PyObject * obj0 = 0 ;
27507 char *kwnames[] = {
27508 (char *) "self", NULL
27509 };
27510
27511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27513 if (SWIG_arg_fail(1)) SWIG_fail;
27514 {
27515 PyThreadState* __tstate = wxPyBeginAllowThreads();
27516 result = (bool)((wxWindow const *)arg1)->IsShown();
27517
27518 wxPyEndAllowThreads(__tstate);
27519 if (PyErr_Occurred()) SWIG_fail;
27520 }
27521 {
27522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27523 }
27524 return resultobj;
27525 fail:
27526 return NULL;
27527 }
27528
27529
27530 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27531 PyObject *resultobj;
27532 wxWindow *arg1 = (wxWindow *) 0 ;
27533 bool result;
27534 PyObject * obj0 = 0 ;
27535 char *kwnames[] = {
27536 (char *) "self", NULL
27537 };
27538
27539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27541 if (SWIG_arg_fail(1)) SWIG_fail;
27542 {
27543 PyThreadState* __tstate = wxPyBeginAllowThreads();
27544 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27545
27546 wxPyEndAllowThreads(__tstate);
27547 if (PyErr_Occurred()) SWIG_fail;
27548 }
27549 {
27550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27551 }
27552 return resultobj;
27553 fail:
27554 return NULL;
27555 }
27556
27557
27558 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27559 PyObject *resultobj;
27560 wxWindow *arg1 = (wxWindow *) 0 ;
27561 long arg2 ;
27562 PyObject * obj0 = 0 ;
27563 PyObject * obj1 = 0 ;
27564 char *kwnames[] = {
27565 (char *) "self",(char *) "style", NULL
27566 };
27567
27568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27570 if (SWIG_arg_fail(1)) SWIG_fail;
27571 {
27572 arg2 = (long)(SWIG_As_long(obj1));
27573 if (SWIG_arg_fail(2)) SWIG_fail;
27574 }
27575 {
27576 PyThreadState* __tstate = wxPyBeginAllowThreads();
27577 (arg1)->SetWindowStyleFlag(arg2);
27578
27579 wxPyEndAllowThreads(__tstate);
27580 if (PyErr_Occurred()) SWIG_fail;
27581 }
27582 Py_INCREF(Py_None); resultobj = Py_None;
27583 return resultobj;
27584 fail:
27585 return NULL;
27586 }
27587
27588
27589 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27590 PyObject *resultobj;
27591 wxWindow *arg1 = (wxWindow *) 0 ;
27592 long result;
27593 PyObject * obj0 = 0 ;
27594 char *kwnames[] = {
27595 (char *) "self", NULL
27596 };
27597
27598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27600 if (SWIG_arg_fail(1)) SWIG_fail;
27601 {
27602 PyThreadState* __tstate = wxPyBeginAllowThreads();
27603 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27604
27605 wxPyEndAllowThreads(__tstate);
27606 if (PyErr_Occurred()) SWIG_fail;
27607 }
27608 {
27609 resultobj = SWIG_From_long((long)(result));
27610 }
27611 return resultobj;
27612 fail:
27613 return NULL;
27614 }
27615
27616
27617 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27618 PyObject *resultobj;
27619 wxWindow *arg1 = (wxWindow *) 0 ;
27620 int arg2 ;
27621 bool result;
27622 PyObject * obj0 = 0 ;
27623 PyObject * obj1 = 0 ;
27624 char *kwnames[] = {
27625 (char *) "self",(char *) "flag", NULL
27626 };
27627
27628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27630 if (SWIG_arg_fail(1)) SWIG_fail;
27631 {
27632 arg2 = (int)(SWIG_As_int(obj1));
27633 if (SWIG_arg_fail(2)) SWIG_fail;
27634 }
27635 {
27636 PyThreadState* __tstate = wxPyBeginAllowThreads();
27637 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27638
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 {
27643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27644 }
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27652 PyObject *resultobj;
27653 wxWindow *arg1 = (wxWindow *) 0 ;
27654 bool result;
27655 PyObject * obj0 = 0 ;
27656 char *kwnames[] = {
27657 (char *) "self", NULL
27658 };
27659
27660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27662 if (SWIG_arg_fail(1)) SWIG_fail;
27663 {
27664 PyThreadState* __tstate = wxPyBeginAllowThreads();
27665 result = (bool)((wxWindow const *)arg1)->IsRetained();
27666
27667 wxPyEndAllowThreads(__tstate);
27668 if (PyErr_Occurred()) SWIG_fail;
27669 }
27670 {
27671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27672 }
27673 return resultobj;
27674 fail:
27675 return NULL;
27676 }
27677
27678
27679 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27680 PyObject *resultobj;
27681 wxWindow *arg1 = (wxWindow *) 0 ;
27682 long arg2 ;
27683 PyObject * obj0 = 0 ;
27684 PyObject * obj1 = 0 ;
27685 char *kwnames[] = {
27686 (char *) "self",(char *) "exStyle", NULL
27687 };
27688
27689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27691 if (SWIG_arg_fail(1)) SWIG_fail;
27692 {
27693 arg2 = (long)(SWIG_As_long(obj1));
27694 if (SWIG_arg_fail(2)) SWIG_fail;
27695 }
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 (arg1)->SetExtraStyle(arg2);
27699
27700 wxPyEndAllowThreads(__tstate);
27701 if (PyErr_Occurred()) SWIG_fail;
27702 }
27703 Py_INCREF(Py_None); resultobj = Py_None;
27704 return resultobj;
27705 fail:
27706 return NULL;
27707 }
27708
27709
27710 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27711 PyObject *resultobj;
27712 wxWindow *arg1 = (wxWindow *) 0 ;
27713 long result;
27714 PyObject * obj0 = 0 ;
27715 char *kwnames[] = {
27716 (char *) "self", NULL
27717 };
27718
27719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27721 if (SWIG_arg_fail(1)) SWIG_fail;
27722 {
27723 PyThreadState* __tstate = wxPyBeginAllowThreads();
27724 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27725
27726 wxPyEndAllowThreads(__tstate);
27727 if (PyErr_Occurred()) SWIG_fail;
27728 }
27729 {
27730 resultobj = SWIG_From_long((long)(result));
27731 }
27732 return resultobj;
27733 fail:
27734 return NULL;
27735 }
27736
27737
27738 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27739 PyObject *resultobj;
27740 wxWindow *arg1 = (wxWindow *) 0 ;
27741 bool arg2 = (bool) true ;
27742 PyObject * obj0 = 0 ;
27743 PyObject * obj1 = 0 ;
27744 char *kwnames[] = {
27745 (char *) "self",(char *) "modal", NULL
27746 };
27747
27748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27750 if (SWIG_arg_fail(1)) SWIG_fail;
27751 if (obj1) {
27752 {
27753 arg2 = (bool)(SWIG_As_bool(obj1));
27754 if (SWIG_arg_fail(2)) SWIG_fail;
27755 }
27756 }
27757 {
27758 PyThreadState* __tstate = wxPyBeginAllowThreads();
27759 (arg1)->MakeModal(arg2);
27760
27761 wxPyEndAllowThreads(__tstate);
27762 if (PyErr_Occurred()) SWIG_fail;
27763 }
27764 Py_INCREF(Py_None); resultobj = Py_None;
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27772 PyObject *resultobj;
27773 wxWindow *arg1 = (wxWindow *) 0 ;
27774 bool arg2 ;
27775 PyObject * obj0 = 0 ;
27776 PyObject * obj1 = 0 ;
27777 char *kwnames[] = {
27778 (char *) "self",(char *) "enableTheme", NULL
27779 };
27780
27781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27783 if (SWIG_arg_fail(1)) SWIG_fail;
27784 {
27785 arg2 = (bool)(SWIG_As_bool(obj1));
27786 if (SWIG_arg_fail(2)) SWIG_fail;
27787 }
27788 {
27789 PyThreadState* __tstate = wxPyBeginAllowThreads();
27790 (arg1)->SetThemeEnabled(arg2);
27791
27792 wxPyEndAllowThreads(__tstate);
27793 if (PyErr_Occurred()) SWIG_fail;
27794 }
27795 Py_INCREF(Py_None); resultobj = Py_None;
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27803 PyObject *resultobj;
27804 wxWindow *arg1 = (wxWindow *) 0 ;
27805 bool result;
27806 PyObject * obj0 = 0 ;
27807 char *kwnames[] = {
27808 (char *) "self", NULL
27809 };
27810
27811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27813 if (SWIG_arg_fail(1)) SWIG_fail;
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27817
27818 wxPyEndAllowThreads(__tstate);
27819 if (PyErr_Occurred()) SWIG_fail;
27820 }
27821 {
27822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27823 }
27824 return resultobj;
27825 fail:
27826 return NULL;
27827 }
27828
27829
27830 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27831 PyObject *resultobj;
27832 wxWindow *arg1 = (wxWindow *) 0 ;
27833 PyObject * obj0 = 0 ;
27834 char *kwnames[] = {
27835 (char *) "self", NULL
27836 };
27837
27838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27840 if (SWIG_arg_fail(1)) SWIG_fail;
27841 {
27842 PyThreadState* __tstate = wxPyBeginAllowThreads();
27843 (arg1)->SetFocus();
27844
27845 wxPyEndAllowThreads(__tstate);
27846 if (PyErr_Occurred()) SWIG_fail;
27847 }
27848 Py_INCREF(Py_None); resultobj = Py_None;
27849 return resultobj;
27850 fail:
27851 return NULL;
27852 }
27853
27854
27855 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27856 PyObject *resultobj;
27857 wxWindow *arg1 = (wxWindow *) 0 ;
27858 PyObject * obj0 = 0 ;
27859 char *kwnames[] = {
27860 (char *) "self", NULL
27861 };
27862
27863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27865 if (SWIG_arg_fail(1)) SWIG_fail;
27866 {
27867 PyThreadState* __tstate = wxPyBeginAllowThreads();
27868 (arg1)->SetFocusFromKbd();
27869
27870 wxPyEndAllowThreads(__tstate);
27871 if (PyErr_Occurred()) SWIG_fail;
27872 }
27873 Py_INCREF(Py_None); resultobj = Py_None;
27874 return resultobj;
27875 fail:
27876 return NULL;
27877 }
27878
27879
27880 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27881 PyObject *resultobj;
27882 wxWindow *result;
27883 char *kwnames[] = {
27884 NULL
27885 };
27886
27887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27888 {
27889 if (!wxPyCheckForApp()) SWIG_fail;
27890 PyThreadState* __tstate = wxPyBeginAllowThreads();
27891 result = (wxWindow *)wxWindow::FindFocus();
27892
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 {
27897 resultobj = wxPyMake_wxObject(result, 0);
27898 }
27899 return resultobj;
27900 fail:
27901 return NULL;
27902 }
27903
27904
27905 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27906 PyObject *resultobj;
27907 wxWindow *arg1 = (wxWindow *) 0 ;
27908 bool result;
27909 PyObject * obj0 = 0 ;
27910 char *kwnames[] = {
27911 (char *) "self", NULL
27912 };
27913
27914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27916 if (SWIG_arg_fail(1)) SWIG_fail;
27917 {
27918 PyThreadState* __tstate = wxPyBeginAllowThreads();
27919 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27920
27921 wxPyEndAllowThreads(__tstate);
27922 if (PyErr_Occurred()) SWIG_fail;
27923 }
27924 {
27925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27926 }
27927 return resultobj;
27928 fail:
27929 return NULL;
27930 }
27931
27932
27933 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27934 PyObject *resultobj;
27935 wxWindow *arg1 = (wxWindow *) 0 ;
27936 bool result;
27937 PyObject * obj0 = 0 ;
27938 char *kwnames[] = {
27939 (char *) "self", NULL
27940 };
27941
27942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27944 if (SWIG_arg_fail(1)) SWIG_fail;
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27948
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj;
27963 wxWindow *arg1 = (wxWindow *) 0 ;
27964 wxWindow *result;
27965 PyObject * obj0 = 0 ;
27966 char *kwnames[] = {
27967 (char *) "self", NULL
27968 };
27969
27970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27972 if (SWIG_arg_fail(1)) SWIG_fail;
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27976
27977 wxPyEndAllowThreads(__tstate);
27978 if (PyErr_Occurred()) SWIG_fail;
27979 }
27980 {
27981 resultobj = wxPyMake_wxObject(result, 0);
27982 }
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27990 PyObject *resultobj;
27991 wxWindow *arg1 = (wxWindow *) 0 ;
27992 wxWindow *arg2 = (wxWindow *) 0 ;
27993 wxWindow *result;
27994 PyObject * obj0 = 0 ;
27995 PyObject * obj1 = 0 ;
27996 char *kwnames[] = {
27997 (char *) "self",(char *) "child", NULL
27998 };
27999
28000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28002 if (SWIG_arg_fail(1)) SWIG_fail;
28003 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28004 if (SWIG_arg_fail(2)) SWIG_fail;
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28008
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 {
28013 resultobj = wxPyMake_wxObject(result, 0);
28014 }
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28022 PyObject *resultobj;
28023 wxWindow *arg1 = (wxWindow *) 0 ;
28024 wxWindow *arg2 = (wxWindow *) 0 ;
28025 PyObject * obj0 = 0 ;
28026 PyObject * obj1 = 0 ;
28027 char *kwnames[] = {
28028 (char *) "self",(char *) "win", NULL
28029 };
28030
28031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28033 if (SWIG_arg_fail(1)) SWIG_fail;
28034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28035 if (SWIG_arg_fail(2)) SWIG_fail;
28036 {
28037 PyThreadState* __tstate = wxPyBeginAllowThreads();
28038 (arg1)->SetTmpDefaultItem(arg2);
28039
28040 wxPyEndAllowThreads(__tstate);
28041 if (PyErr_Occurred()) SWIG_fail;
28042 }
28043 Py_INCREF(Py_None); resultobj = Py_None;
28044 return resultobj;
28045 fail:
28046 return NULL;
28047 }
28048
28049
28050 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28051 PyObject *resultobj;
28052 wxWindow *arg1 = (wxWindow *) 0 ;
28053 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28054 bool result;
28055 PyObject * obj0 = 0 ;
28056 PyObject * obj1 = 0 ;
28057 char *kwnames[] = {
28058 (char *) "self",(char *) "flags", NULL
28059 };
28060
28061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28063 if (SWIG_arg_fail(1)) SWIG_fail;
28064 if (obj1) {
28065 {
28066 arg2 = (int)(SWIG_As_int(obj1));
28067 if (SWIG_arg_fail(2)) SWIG_fail;
28068 }
28069 }
28070 {
28071 PyThreadState* __tstate = wxPyBeginAllowThreads();
28072 result = (bool)(arg1)->Navigate(arg2);
28073
28074 wxPyEndAllowThreads(__tstate);
28075 if (PyErr_Occurred()) SWIG_fail;
28076 }
28077 {
28078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28079 }
28080 return resultobj;
28081 fail:
28082 return NULL;
28083 }
28084
28085
28086 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28087 PyObject *resultobj;
28088 wxWindow *arg1 = (wxWindow *) 0 ;
28089 wxWindow *arg2 = (wxWindow *) 0 ;
28090 PyObject * obj0 = 0 ;
28091 PyObject * obj1 = 0 ;
28092 char *kwnames[] = {
28093 (char *) "self",(char *) "win", NULL
28094 };
28095
28096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28098 if (SWIG_arg_fail(1)) SWIG_fail;
28099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28100 if (SWIG_arg_fail(2)) SWIG_fail;
28101 {
28102 PyThreadState* __tstate = wxPyBeginAllowThreads();
28103 (arg1)->MoveAfterInTabOrder(arg2);
28104
28105 wxPyEndAllowThreads(__tstate);
28106 if (PyErr_Occurred()) SWIG_fail;
28107 }
28108 Py_INCREF(Py_None); resultobj = Py_None;
28109 return resultobj;
28110 fail:
28111 return NULL;
28112 }
28113
28114
28115 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28116 PyObject *resultobj;
28117 wxWindow *arg1 = (wxWindow *) 0 ;
28118 wxWindow *arg2 = (wxWindow *) 0 ;
28119 PyObject * obj0 = 0 ;
28120 PyObject * obj1 = 0 ;
28121 char *kwnames[] = {
28122 (char *) "self",(char *) "win", NULL
28123 };
28124
28125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28127 if (SWIG_arg_fail(1)) SWIG_fail;
28128 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28129 if (SWIG_arg_fail(2)) SWIG_fail;
28130 {
28131 PyThreadState* __tstate = wxPyBeginAllowThreads();
28132 (arg1)->MoveBeforeInTabOrder(arg2);
28133
28134 wxPyEndAllowThreads(__tstate);
28135 if (PyErr_Occurred()) SWIG_fail;
28136 }
28137 Py_INCREF(Py_None); resultobj = Py_None;
28138 return resultobj;
28139 fail:
28140 return NULL;
28141 }
28142
28143
28144 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28145 PyObject *resultobj;
28146 wxWindow *arg1 = (wxWindow *) 0 ;
28147 PyObject *result;
28148 PyObject * obj0 = 0 ;
28149 char *kwnames[] = {
28150 (char *) "self", NULL
28151 };
28152
28153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28155 if (SWIG_arg_fail(1)) SWIG_fail;
28156 {
28157 PyThreadState* __tstate = wxPyBeginAllowThreads();
28158 result = (PyObject *)wxWindow_GetChildren(arg1);
28159
28160 wxPyEndAllowThreads(__tstate);
28161 if (PyErr_Occurred()) SWIG_fail;
28162 }
28163 resultobj = result;
28164 return resultobj;
28165 fail:
28166 return NULL;
28167 }
28168
28169
28170 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28171 PyObject *resultobj;
28172 wxWindow *arg1 = (wxWindow *) 0 ;
28173 wxWindow *result;
28174 PyObject * obj0 = 0 ;
28175 char *kwnames[] = {
28176 (char *) "self", NULL
28177 };
28178
28179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28181 if (SWIG_arg_fail(1)) SWIG_fail;
28182 {
28183 PyThreadState* __tstate = wxPyBeginAllowThreads();
28184 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28185
28186 wxPyEndAllowThreads(__tstate);
28187 if (PyErr_Occurred()) SWIG_fail;
28188 }
28189 {
28190 resultobj = wxPyMake_wxObject(result, 0);
28191 }
28192 return resultobj;
28193 fail:
28194 return NULL;
28195 }
28196
28197
28198 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28199 PyObject *resultobj;
28200 wxWindow *arg1 = (wxWindow *) 0 ;
28201 wxWindow *result;
28202 PyObject * obj0 = 0 ;
28203 char *kwnames[] = {
28204 (char *) "self", NULL
28205 };
28206
28207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28209 if (SWIG_arg_fail(1)) SWIG_fail;
28210 {
28211 PyThreadState* __tstate = wxPyBeginAllowThreads();
28212 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28213
28214 wxPyEndAllowThreads(__tstate);
28215 if (PyErr_Occurred()) SWIG_fail;
28216 }
28217 {
28218 resultobj = wxPyMake_wxObject(result, 0);
28219 }
28220 return resultobj;
28221 fail:
28222 return NULL;
28223 }
28224
28225
28226 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28227 PyObject *resultobj;
28228 wxWindow *arg1 = (wxWindow *) 0 ;
28229 bool result;
28230 PyObject * obj0 = 0 ;
28231 char *kwnames[] = {
28232 (char *) "self", NULL
28233 };
28234
28235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28237 if (SWIG_arg_fail(1)) SWIG_fail;
28238 {
28239 PyThreadState* __tstate = wxPyBeginAllowThreads();
28240 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28241
28242 wxPyEndAllowThreads(__tstate);
28243 if (PyErr_Occurred()) SWIG_fail;
28244 }
28245 {
28246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28247 }
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28255 PyObject *resultobj;
28256 wxWindow *arg1 = (wxWindow *) 0 ;
28257 wxWindow *arg2 = (wxWindow *) 0 ;
28258 bool result;
28259 PyObject * obj0 = 0 ;
28260 PyObject * obj1 = 0 ;
28261 char *kwnames[] = {
28262 (char *) "self",(char *) "newParent", NULL
28263 };
28264
28265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28267 if (SWIG_arg_fail(1)) SWIG_fail;
28268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28269 if (SWIG_arg_fail(2)) SWIG_fail;
28270 {
28271 PyThreadState* __tstate = wxPyBeginAllowThreads();
28272 result = (bool)(arg1)->Reparent(arg2);
28273
28274 wxPyEndAllowThreads(__tstate);
28275 if (PyErr_Occurred()) SWIG_fail;
28276 }
28277 {
28278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28279 }
28280 return resultobj;
28281 fail:
28282 return NULL;
28283 }
28284
28285
28286 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28287 PyObject *resultobj;
28288 wxWindow *arg1 = (wxWindow *) 0 ;
28289 wxWindow *arg2 = (wxWindow *) 0 ;
28290 PyObject * obj0 = 0 ;
28291 PyObject * obj1 = 0 ;
28292 char *kwnames[] = {
28293 (char *) "self",(char *) "child", NULL
28294 };
28295
28296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28298 if (SWIG_arg_fail(1)) SWIG_fail;
28299 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28300 if (SWIG_arg_fail(2)) SWIG_fail;
28301 {
28302 PyThreadState* __tstate = wxPyBeginAllowThreads();
28303 (arg1)->AddChild(arg2);
28304
28305 wxPyEndAllowThreads(__tstate);
28306 if (PyErr_Occurred()) SWIG_fail;
28307 }
28308 Py_INCREF(Py_None); resultobj = Py_None;
28309 return resultobj;
28310 fail:
28311 return NULL;
28312 }
28313
28314
28315 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28316 PyObject *resultobj;
28317 wxWindow *arg1 = (wxWindow *) 0 ;
28318 wxWindow *arg2 = (wxWindow *) 0 ;
28319 PyObject * obj0 = 0 ;
28320 PyObject * obj1 = 0 ;
28321 char *kwnames[] = {
28322 (char *) "self",(char *) "child", NULL
28323 };
28324
28325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28327 if (SWIG_arg_fail(1)) SWIG_fail;
28328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28329 if (SWIG_arg_fail(2)) SWIG_fail;
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 (arg1)->RemoveChild(arg2);
28333
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 Py_INCREF(Py_None); resultobj = Py_None;
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28345 PyObject *resultobj;
28346 wxWindow *arg1 = (wxWindow *) 0 ;
28347 long arg2 ;
28348 wxWindow *result;
28349 PyObject * obj0 = 0 ;
28350 PyObject * obj1 = 0 ;
28351 char *kwnames[] = {
28352 (char *) "self",(char *) "winid", NULL
28353 };
28354
28355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28357 if (SWIG_arg_fail(1)) SWIG_fail;
28358 {
28359 arg2 = (long)(SWIG_As_long(obj1));
28360 if (SWIG_arg_fail(2)) SWIG_fail;
28361 }
28362 {
28363 PyThreadState* __tstate = wxPyBeginAllowThreads();
28364 result = (wxWindow *)(arg1)->FindWindow(arg2);
28365
28366 wxPyEndAllowThreads(__tstate);
28367 if (PyErr_Occurred()) SWIG_fail;
28368 }
28369 {
28370 resultobj = wxPyMake_wxObject(result, 0);
28371 }
28372 return resultobj;
28373 fail:
28374 return NULL;
28375 }
28376
28377
28378 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28379 PyObject *resultobj;
28380 wxWindow *arg1 = (wxWindow *) 0 ;
28381 wxString *arg2 = 0 ;
28382 wxWindow *result;
28383 bool temp2 = false ;
28384 PyObject * obj0 = 0 ;
28385 PyObject * obj1 = 0 ;
28386 char *kwnames[] = {
28387 (char *) "self",(char *) "name", NULL
28388 };
28389
28390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28392 if (SWIG_arg_fail(1)) SWIG_fail;
28393 {
28394 arg2 = wxString_in_helper(obj1);
28395 if (arg2 == NULL) SWIG_fail;
28396 temp2 = true;
28397 }
28398 {
28399 PyThreadState* __tstate = wxPyBeginAllowThreads();
28400 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28401
28402 wxPyEndAllowThreads(__tstate);
28403 if (PyErr_Occurred()) SWIG_fail;
28404 }
28405 {
28406 resultobj = wxPyMake_wxObject(result, 0);
28407 }
28408 {
28409 if (temp2)
28410 delete arg2;
28411 }
28412 return resultobj;
28413 fail:
28414 {
28415 if (temp2)
28416 delete arg2;
28417 }
28418 return NULL;
28419 }
28420
28421
28422 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28423 PyObject *resultobj;
28424 wxWindow *arg1 = (wxWindow *) 0 ;
28425 wxEvtHandler *result;
28426 PyObject * obj0 = 0 ;
28427 char *kwnames[] = {
28428 (char *) "self", NULL
28429 };
28430
28431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28433 if (SWIG_arg_fail(1)) SWIG_fail;
28434 {
28435 PyThreadState* __tstate = wxPyBeginAllowThreads();
28436 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28437
28438 wxPyEndAllowThreads(__tstate);
28439 if (PyErr_Occurred()) SWIG_fail;
28440 }
28441 {
28442 resultobj = wxPyMake_wxObject(result, 0);
28443 }
28444 return resultobj;
28445 fail:
28446 return NULL;
28447 }
28448
28449
28450 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28451 PyObject *resultobj;
28452 wxWindow *arg1 = (wxWindow *) 0 ;
28453 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28454 PyObject * obj0 = 0 ;
28455 PyObject * obj1 = 0 ;
28456 char *kwnames[] = {
28457 (char *) "self",(char *) "handler", NULL
28458 };
28459
28460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28462 if (SWIG_arg_fail(1)) SWIG_fail;
28463 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28464 if (SWIG_arg_fail(2)) SWIG_fail;
28465 {
28466 PyThreadState* __tstate = wxPyBeginAllowThreads();
28467 (arg1)->SetEventHandler(arg2);
28468
28469 wxPyEndAllowThreads(__tstate);
28470 if (PyErr_Occurred()) SWIG_fail;
28471 }
28472 Py_INCREF(Py_None); resultobj = Py_None;
28473 return resultobj;
28474 fail:
28475 return NULL;
28476 }
28477
28478
28479 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28480 PyObject *resultobj;
28481 wxWindow *arg1 = (wxWindow *) 0 ;
28482 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28483 PyObject * obj0 = 0 ;
28484 PyObject * obj1 = 0 ;
28485 char *kwnames[] = {
28486 (char *) "self",(char *) "handler", NULL
28487 };
28488
28489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28491 if (SWIG_arg_fail(1)) SWIG_fail;
28492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28493 if (SWIG_arg_fail(2)) SWIG_fail;
28494 {
28495 PyThreadState* __tstate = wxPyBeginAllowThreads();
28496 (arg1)->PushEventHandler(arg2);
28497
28498 wxPyEndAllowThreads(__tstate);
28499 if (PyErr_Occurred()) SWIG_fail;
28500 }
28501 Py_INCREF(Py_None); resultobj = Py_None;
28502 return resultobj;
28503 fail:
28504 return NULL;
28505 }
28506
28507
28508 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28509 PyObject *resultobj;
28510 wxWindow *arg1 = (wxWindow *) 0 ;
28511 bool arg2 = (bool) false ;
28512 wxEvtHandler *result;
28513 PyObject * obj0 = 0 ;
28514 PyObject * obj1 = 0 ;
28515 char *kwnames[] = {
28516 (char *) "self",(char *) "deleteHandler", NULL
28517 };
28518
28519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28521 if (SWIG_arg_fail(1)) SWIG_fail;
28522 if (obj1) {
28523 {
28524 arg2 = (bool)(SWIG_As_bool(obj1));
28525 if (SWIG_arg_fail(2)) SWIG_fail;
28526 }
28527 }
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28531
28532 wxPyEndAllowThreads(__tstate);
28533 if (PyErr_Occurred()) SWIG_fail;
28534 }
28535 {
28536 resultobj = wxPyMake_wxObject(result, 0);
28537 }
28538 return resultobj;
28539 fail:
28540 return NULL;
28541 }
28542
28543
28544 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28545 PyObject *resultobj;
28546 wxWindow *arg1 = (wxWindow *) 0 ;
28547 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28548 bool result;
28549 PyObject * obj0 = 0 ;
28550 PyObject * obj1 = 0 ;
28551 char *kwnames[] = {
28552 (char *) "self",(char *) "handler", NULL
28553 };
28554
28555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28559 if (SWIG_arg_fail(2)) SWIG_fail;
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 result = (bool)(arg1)->RemoveEventHandler(arg2);
28563
28564 wxPyEndAllowThreads(__tstate);
28565 if (PyErr_Occurred()) SWIG_fail;
28566 }
28567 {
28568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28569 }
28570 return resultobj;
28571 fail:
28572 return NULL;
28573 }
28574
28575
28576 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28577 PyObject *resultobj;
28578 wxWindow *arg1 = (wxWindow *) 0 ;
28579 wxValidator *arg2 = 0 ;
28580 PyObject * obj0 = 0 ;
28581 PyObject * obj1 = 0 ;
28582 char *kwnames[] = {
28583 (char *) "self",(char *) "validator", NULL
28584 };
28585
28586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28588 if (SWIG_arg_fail(1)) SWIG_fail;
28589 {
28590 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28591 if (SWIG_arg_fail(2)) SWIG_fail;
28592 if (arg2 == NULL) {
28593 SWIG_null_ref("wxValidator");
28594 }
28595 if (SWIG_arg_fail(2)) SWIG_fail;
28596 }
28597 {
28598 PyThreadState* __tstate = wxPyBeginAllowThreads();
28599 (arg1)->SetValidator((wxValidator const &)*arg2);
28600
28601 wxPyEndAllowThreads(__tstate);
28602 if (PyErr_Occurred()) SWIG_fail;
28603 }
28604 Py_INCREF(Py_None); resultobj = Py_None;
28605 return resultobj;
28606 fail:
28607 return NULL;
28608 }
28609
28610
28611 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28612 PyObject *resultobj;
28613 wxWindow *arg1 = (wxWindow *) 0 ;
28614 wxValidator *result;
28615 PyObject * obj0 = 0 ;
28616 char *kwnames[] = {
28617 (char *) "self", NULL
28618 };
28619
28620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28622 if (SWIG_arg_fail(1)) SWIG_fail;
28623 {
28624 PyThreadState* __tstate = wxPyBeginAllowThreads();
28625 result = (wxValidator *)(arg1)->GetValidator();
28626
28627 wxPyEndAllowThreads(__tstate);
28628 if (PyErr_Occurred()) SWIG_fail;
28629 }
28630 {
28631 resultobj = wxPyMake_wxObject(result, 0);
28632 }
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj;
28641 wxWindow *arg1 = (wxWindow *) 0 ;
28642 bool result;
28643 PyObject * obj0 = 0 ;
28644 char *kwnames[] = {
28645 (char *) "self", NULL
28646 };
28647
28648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28650 if (SWIG_arg_fail(1)) SWIG_fail;
28651 {
28652 PyThreadState* __tstate = wxPyBeginAllowThreads();
28653 result = (bool)(arg1)->Validate();
28654
28655 wxPyEndAllowThreads(__tstate);
28656 if (PyErr_Occurred()) SWIG_fail;
28657 }
28658 {
28659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28660 }
28661 return resultobj;
28662 fail:
28663 return NULL;
28664 }
28665
28666
28667 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28668 PyObject *resultobj;
28669 wxWindow *arg1 = (wxWindow *) 0 ;
28670 bool result;
28671 PyObject * obj0 = 0 ;
28672 char *kwnames[] = {
28673 (char *) "self", NULL
28674 };
28675
28676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28678 if (SWIG_arg_fail(1)) SWIG_fail;
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 result = (bool)(arg1)->TransferDataToWindow();
28682
28683 wxPyEndAllowThreads(__tstate);
28684 if (PyErr_Occurred()) SWIG_fail;
28685 }
28686 {
28687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28688 }
28689 return resultobj;
28690 fail:
28691 return NULL;
28692 }
28693
28694
28695 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28696 PyObject *resultobj;
28697 wxWindow *arg1 = (wxWindow *) 0 ;
28698 bool result;
28699 PyObject * obj0 = 0 ;
28700 char *kwnames[] = {
28701 (char *) "self", NULL
28702 };
28703
28704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28706 if (SWIG_arg_fail(1)) SWIG_fail;
28707 {
28708 PyThreadState* __tstate = wxPyBeginAllowThreads();
28709 result = (bool)(arg1)->TransferDataFromWindow();
28710
28711 wxPyEndAllowThreads(__tstate);
28712 if (PyErr_Occurred()) SWIG_fail;
28713 }
28714 {
28715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28716 }
28717 return resultobj;
28718 fail:
28719 return NULL;
28720 }
28721
28722
28723 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28724 PyObject *resultobj;
28725 wxWindow *arg1 = (wxWindow *) 0 ;
28726 PyObject * obj0 = 0 ;
28727 char *kwnames[] = {
28728 (char *) "self", NULL
28729 };
28730
28731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28733 if (SWIG_arg_fail(1)) SWIG_fail;
28734 {
28735 PyThreadState* __tstate = wxPyBeginAllowThreads();
28736 (arg1)->InitDialog();
28737
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 Py_INCREF(Py_None); resultobj = Py_None;
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28749 PyObject *resultobj;
28750 wxWindow *arg1 = (wxWindow *) 0 ;
28751 wxAcceleratorTable *arg2 = 0 ;
28752 PyObject * obj0 = 0 ;
28753 PyObject * obj1 = 0 ;
28754 char *kwnames[] = {
28755 (char *) "self",(char *) "accel", NULL
28756 };
28757
28758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28760 if (SWIG_arg_fail(1)) SWIG_fail;
28761 {
28762 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28763 if (SWIG_arg_fail(2)) SWIG_fail;
28764 if (arg2 == NULL) {
28765 SWIG_null_ref("wxAcceleratorTable");
28766 }
28767 if (SWIG_arg_fail(2)) SWIG_fail;
28768 }
28769 {
28770 PyThreadState* __tstate = wxPyBeginAllowThreads();
28771 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28772
28773 wxPyEndAllowThreads(__tstate);
28774 if (PyErr_Occurred()) SWIG_fail;
28775 }
28776 Py_INCREF(Py_None); resultobj = Py_None;
28777 return resultobj;
28778 fail:
28779 return NULL;
28780 }
28781
28782
28783 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28784 PyObject *resultobj;
28785 wxWindow *arg1 = (wxWindow *) 0 ;
28786 wxAcceleratorTable *result;
28787 PyObject * obj0 = 0 ;
28788 char *kwnames[] = {
28789 (char *) "self", NULL
28790 };
28791
28792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28794 if (SWIG_arg_fail(1)) SWIG_fail;
28795 {
28796 PyThreadState* __tstate = wxPyBeginAllowThreads();
28797 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28798
28799 wxPyEndAllowThreads(__tstate);
28800 if (PyErr_Occurred()) SWIG_fail;
28801 }
28802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28810 PyObject *resultobj;
28811 wxWindow *arg1 = (wxWindow *) 0 ;
28812 int arg2 ;
28813 int arg3 ;
28814 int arg4 ;
28815 bool result;
28816 PyObject * obj0 = 0 ;
28817 PyObject * obj1 = 0 ;
28818 PyObject * obj2 = 0 ;
28819 PyObject * obj3 = 0 ;
28820 char *kwnames[] = {
28821 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28822 };
28823
28824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28826 if (SWIG_arg_fail(1)) SWIG_fail;
28827 {
28828 arg2 = (int)(SWIG_As_int(obj1));
28829 if (SWIG_arg_fail(2)) SWIG_fail;
28830 }
28831 {
28832 arg3 = (int)(SWIG_As_int(obj2));
28833 if (SWIG_arg_fail(3)) SWIG_fail;
28834 }
28835 {
28836 arg4 = (int)(SWIG_As_int(obj3));
28837 if (SWIG_arg_fail(4)) SWIG_fail;
28838 }
28839 {
28840 PyThreadState* __tstate = wxPyBeginAllowThreads();
28841 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28842
28843 wxPyEndAllowThreads(__tstate);
28844 if (PyErr_Occurred()) SWIG_fail;
28845 }
28846 {
28847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28848 }
28849 return resultobj;
28850 fail:
28851 return NULL;
28852 }
28853
28854
28855 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28856 PyObject *resultobj;
28857 wxWindow *arg1 = (wxWindow *) 0 ;
28858 int arg2 ;
28859 bool result;
28860 PyObject * obj0 = 0 ;
28861 PyObject * obj1 = 0 ;
28862 char *kwnames[] = {
28863 (char *) "self",(char *) "hotkeyId", NULL
28864 };
28865
28866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28868 if (SWIG_arg_fail(1)) SWIG_fail;
28869 {
28870 arg2 = (int)(SWIG_As_int(obj1));
28871 if (SWIG_arg_fail(2)) SWIG_fail;
28872 }
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28876
28877 wxPyEndAllowThreads(__tstate);
28878 if (PyErr_Occurred()) SWIG_fail;
28879 }
28880 {
28881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28882 }
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj;
28891 wxWindow *arg1 = (wxWindow *) 0 ;
28892 wxPoint *arg2 = 0 ;
28893 wxPoint result;
28894 wxPoint temp2 ;
28895 PyObject * obj0 = 0 ;
28896 PyObject * obj1 = 0 ;
28897 char *kwnames[] = {
28898 (char *) "self",(char *) "pt", NULL
28899 };
28900
28901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28903 if (SWIG_arg_fail(1)) SWIG_fail;
28904 {
28905 arg2 = &temp2;
28906 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28907 }
28908 {
28909 PyThreadState* __tstate = wxPyBeginAllowThreads();
28910 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28911
28912 wxPyEndAllowThreads(__tstate);
28913 if (PyErr_Occurred()) SWIG_fail;
28914 }
28915 {
28916 wxPoint * resultptr;
28917 resultptr = new wxPoint((wxPoint &)(result));
28918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28919 }
28920 return resultobj;
28921 fail:
28922 return NULL;
28923 }
28924
28925
28926 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28927 PyObject *resultobj;
28928 wxWindow *arg1 = (wxWindow *) 0 ;
28929 wxSize *arg2 = 0 ;
28930 wxSize result;
28931 wxSize temp2 ;
28932 PyObject * obj0 = 0 ;
28933 PyObject * obj1 = 0 ;
28934 char *kwnames[] = {
28935 (char *) "self",(char *) "sz", NULL
28936 };
28937
28938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28940 if (SWIG_arg_fail(1)) SWIG_fail;
28941 {
28942 arg2 = &temp2;
28943 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28944 }
28945 {
28946 PyThreadState* __tstate = wxPyBeginAllowThreads();
28947 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28948
28949 wxPyEndAllowThreads(__tstate);
28950 if (PyErr_Occurred()) SWIG_fail;
28951 }
28952 {
28953 wxSize * resultptr;
28954 resultptr = new wxSize((wxSize &)(result));
28955 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28956 }
28957 return resultobj;
28958 fail:
28959 return NULL;
28960 }
28961
28962
28963 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28964 PyObject *resultobj;
28965 wxWindow *arg1 = (wxWindow *) 0 ;
28966 wxPoint *arg2 = 0 ;
28967 wxPoint result;
28968 wxPoint temp2 ;
28969 PyObject * obj0 = 0 ;
28970 PyObject * obj1 = 0 ;
28971 char *kwnames[] = {
28972 (char *) "self",(char *) "pt", NULL
28973 };
28974
28975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28977 if (SWIG_arg_fail(1)) SWIG_fail;
28978 {
28979 arg2 = &temp2;
28980 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28981 }
28982 {
28983 PyThreadState* __tstate = wxPyBeginAllowThreads();
28984 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28985
28986 wxPyEndAllowThreads(__tstate);
28987 if (PyErr_Occurred()) SWIG_fail;
28988 }
28989 {
28990 wxPoint * resultptr;
28991 resultptr = new wxPoint((wxPoint &)(result));
28992 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28993 }
28994 return resultobj;
28995 fail:
28996 return NULL;
28997 }
28998
28999
29000 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29001 PyObject *resultobj;
29002 wxWindow *arg1 = (wxWindow *) 0 ;
29003 wxSize *arg2 = 0 ;
29004 wxSize result;
29005 wxSize temp2 ;
29006 PyObject * obj0 = 0 ;
29007 PyObject * obj1 = 0 ;
29008 char *kwnames[] = {
29009 (char *) "self",(char *) "sz", NULL
29010 };
29011
29012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29014 if (SWIG_arg_fail(1)) SWIG_fail;
29015 {
29016 arg2 = &temp2;
29017 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29018 }
29019 {
29020 PyThreadState* __tstate = wxPyBeginAllowThreads();
29021 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29022
29023 wxPyEndAllowThreads(__tstate);
29024 if (PyErr_Occurred()) SWIG_fail;
29025 }
29026 {
29027 wxSize * resultptr;
29028 resultptr = new wxSize((wxSize &)(result));
29029 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29030 }
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29038 PyObject *resultobj;
29039 wxWindow *arg1 = (wxWindow *) 0 ;
29040 wxPoint *arg2 = 0 ;
29041 wxPoint result;
29042 wxPoint temp2 ;
29043 PyObject * obj0 = 0 ;
29044 PyObject * obj1 = 0 ;
29045 char *kwnames[] = {
29046 (char *) "self",(char *) "pt", NULL
29047 };
29048
29049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29051 if (SWIG_arg_fail(1)) SWIG_fail;
29052 {
29053 arg2 = &temp2;
29054 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29055 }
29056 {
29057 PyThreadState* __tstate = wxPyBeginAllowThreads();
29058 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29059
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 {
29064 wxPoint * resultptr;
29065 resultptr = new wxPoint((wxPoint &)(result));
29066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29067 }
29068 return resultobj;
29069 fail:
29070 return NULL;
29071 }
29072
29073
29074 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29075 PyObject *resultobj;
29076 wxWindow *arg1 = (wxWindow *) 0 ;
29077 wxSize *arg2 = 0 ;
29078 wxSize result;
29079 wxSize temp2 ;
29080 PyObject * obj0 = 0 ;
29081 PyObject * obj1 = 0 ;
29082 char *kwnames[] = {
29083 (char *) "self",(char *) "sz", NULL
29084 };
29085
29086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29088 if (SWIG_arg_fail(1)) SWIG_fail;
29089 {
29090 arg2 = &temp2;
29091 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29092 }
29093 {
29094 PyThreadState* __tstate = wxPyBeginAllowThreads();
29095 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29096
29097 wxPyEndAllowThreads(__tstate);
29098 if (PyErr_Occurred()) SWIG_fail;
29099 }
29100 {
29101 wxSize * resultptr;
29102 resultptr = new wxSize((wxSize &)(result));
29103 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29104 }
29105 return resultobj;
29106 fail:
29107 return NULL;
29108 }
29109
29110
29111 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29112 PyObject *resultobj;
29113 wxWindow *arg1 = (wxWindow *) 0 ;
29114 int arg2 ;
29115 int arg3 ;
29116 PyObject * obj0 = 0 ;
29117 PyObject * obj1 = 0 ;
29118 PyObject * obj2 = 0 ;
29119 char *kwnames[] = {
29120 (char *) "self",(char *) "x",(char *) "y", NULL
29121 };
29122
29123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29125 if (SWIG_arg_fail(1)) SWIG_fail;
29126 {
29127 arg2 = (int)(SWIG_As_int(obj1));
29128 if (SWIG_arg_fail(2)) SWIG_fail;
29129 }
29130 {
29131 arg3 = (int)(SWIG_As_int(obj2));
29132 if (SWIG_arg_fail(3)) SWIG_fail;
29133 }
29134 {
29135 PyThreadState* __tstate = wxPyBeginAllowThreads();
29136 (arg1)->WarpPointer(arg2,arg3);
29137
29138 wxPyEndAllowThreads(__tstate);
29139 if (PyErr_Occurred()) SWIG_fail;
29140 }
29141 Py_INCREF(Py_None); resultobj = Py_None;
29142 return resultobj;
29143 fail:
29144 return NULL;
29145 }
29146
29147
29148 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29149 PyObject *resultobj;
29150 wxWindow *arg1 = (wxWindow *) 0 ;
29151 PyObject * obj0 = 0 ;
29152 char *kwnames[] = {
29153 (char *) "self", NULL
29154 };
29155
29156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29158 if (SWIG_arg_fail(1)) SWIG_fail;
29159 {
29160 PyThreadState* __tstate = wxPyBeginAllowThreads();
29161 (arg1)->CaptureMouse();
29162
29163 wxPyEndAllowThreads(__tstate);
29164 if (PyErr_Occurred()) SWIG_fail;
29165 }
29166 Py_INCREF(Py_None); resultobj = Py_None;
29167 return resultobj;
29168 fail:
29169 return NULL;
29170 }
29171
29172
29173 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29174 PyObject *resultobj;
29175 wxWindow *arg1 = (wxWindow *) 0 ;
29176 PyObject * obj0 = 0 ;
29177 char *kwnames[] = {
29178 (char *) "self", NULL
29179 };
29180
29181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29183 if (SWIG_arg_fail(1)) SWIG_fail;
29184 {
29185 PyThreadState* __tstate = wxPyBeginAllowThreads();
29186 (arg1)->ReleaseMouse();
29187
29188 wxPyEndAllowThreads(__tstate);
29189 if (PyErr_Occurred()) SWIG_fail;
29190 }
29191 Py_INCREF(Py_None); resultobj = Py_None;
29192 return resultobj;
29193 fail:
29194 return NULL;
29195 }
29196
29197
29198 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29199 PyObject *resultobj;
29200 wxWindow *result;
29201 char *kwnames[] = {
29202 NULL
29203 };
29204
29205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29206 {
29207 if (!wxPyCheckForApp()) SWIG_fail;
29208 PyThreadState* __tstate = wxPyBeginAllowThreads();
29209 result = (wxWindow *)wxWindow::GetCapture();
29210
29211 wxPyEndAllowThreads(__tstate);
29212 if (PyErr_Occurred()) SWIG_fail;
29213 }
29214 {
29215 resultobj = wxPyMake_wxObject(result, 0);
29216 }
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29224 PyObject *resultobj;
29225 wxWindow *arg1 = (wxWindow *) 0 ;
29226 bool result;
29227 PyObject * obj0 = 0 ;
29228 char *kwnames[] = {
29229 (char *) "self", NULL
29230 };
29231
29232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29234 if (SWIG_arg_fail(1)) SWIG_fail;
29235 {
29236 PyThreadState* __tstate = wxPyBeginAllowThreads();
29237 result = (bool)((wxWindow const *)arg1)->HasCapture();
29238
29239 wxPyEndAllowThreads(__tstate);
29240 if (PyErr_Occurred()) SWIG_fail;
29241 }
29242 {
29243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29244 }
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29252 PyObject *resultobj;
29253 wxWindow *arg1 = (wxWindow *) 0 ;
29254 bool arg2 = (bool) true ;
29255 wxRect *arg3 = (wxRect *) NULL ;
29256 PyObject * obj0 = 0 ;
29257 PyObject * obj1 = 0 ;
29258 PyObject * obj2 = 0 ;
29259 char *kwnames[] = {
29260 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29261 };
29262
29263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29265 if (SWIG_arg_fail(1)) SWIG_fail;
29266 if (obj1) {
29267 {
29268 arg2 = (bool)(SWIG_As_bool(obj1));
29269 if (SWIG_arg_fail(2)) SWIG_fail;
29270 }
29271 }
29272 if (obj2) {
29273 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29274 if (SWIG_arg_fail(3)) SWIG_fail;
29275 }
29276 {
29277 PyThreadState* __tstate = wxPyBeginAllowThreads();
29278 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29279
29280 wxPyEndAllowThreads(__tstate);
29281 if (PyErr_Occurred()) SWIG_fail;
29282 }
29283 Py_INCREF(Py_None); resultobj = Py_None;
29284 return resultobj;
29285 fail:
29286 return NULL;
29287 }
29288
29289
29290 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29291 PyObject *resultobj;
29292 wxWindow *arg1 = (wxWindow *) 0 ;
29293 wxRect *arg2 = 0 ;
29294 bool arg3 = (bool) true ;
29295 wxRect temp2 ;
29296 PyObject * obj0 = 0 ;
29297 PyObject * obj1 = 0 ;
29298 PyObject * obj2 = 0 ;
29299 char *kwnames[] = {
29300 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29301 };
29302
29303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29305 if (SWIG_arg_fail(1)) SWIG_fail;
29306 {
29307 arg2 = &temp2;
29308 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29309 }
29310 if (obj2) {
29311 {
29312 arg3 = (bool)(SWIG_As_bool(obj2));
29313 if (SWIG_arg_fail(3)) SWIG_fail;
29314 }
29315 }
29316 {
29317 PyThreadState* __tstate = wxPyBeginAllowThreads();
29318 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29319
29320 wxPyEndAllowThreads(__tstate);
29321 if (PyErr_Occurred()) SWIG_fail;
29322 }
29323 Py_INCREF(Py_None); resultobj = Py_None;
29324 return resultobj;
29325 fail:
29326 return NULL;
29327 }
29328
29329
29330 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29331 PyObject *resultobj;
29332 wxWindow *arg1 = (wxWindow *) 0 ;
29333 PyObject * obj0 = 0 ;
29334 char *kwnames[] = {
29335 (char *) "self", NULL
29336 };
29337
29338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29340 if (SWIG_arg_fail(1)) SWIG_fail;
29341 {
29342 PyThreadState* __tstate = wxPyBeginAllowThreads();
29343 (arg1)->Update();
29344
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 Py_INCREF(Py_None); resultobj = Py_None;
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29356 PyObject *resultobj;
29357 wxWindow *arg1 = (wxWindow *) 0 ;
29358 PyObject * obj0 = 0 ;
29359 char *kwnames[] = {
29360 (char *) "self", NULL
29361 };
29362
29363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29365 if (SWIG_arg_fail(1)) SWIG_fail;
29366 {
29367 PyThreadState* __tstate = wxPyBeginAllowThreads();
29368 (arg1)->ClearBackground();
29369
29370 wxPyEndAllowThreads(__tstate);
29371 if (PyErr_Occurred()) SWIG_fail;
29372 }
29373 Py_INCREF(Py_None); resultobj = Py_None;
29374 return resultobj;
29375 fail:
29376 return NULL;
29377 }
29378
29379
29380 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29381 PyObject *resultobj;
29382 wxWindow *arg1 = (wxWindow *) 0 ;
29383 PyObject * obj0 = 0 ;
29384 char *kwnames[] = {
29385 (char *) "self", NULL
29386 };
29387
29388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29390 if (SWIG_arg_fail(1)) SWIG_fail;
29391 {
29392 PyThreadState* __tstate = wxPyBeginAllowThreads();
29393 (arg1)->Freeze();
29394
29395 wxPyEndAllowThreads(__tstate);
29396 if (PyErr_Occurred()) SWIG_fail;
29397 }
29398 Py_INCREF(Py_None); resultobj = Py_None;
29399 return resultobj;
29400 fail:
29401 return NULL;
29402 }
29403
29404
29405 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29406 PyObject *resultobj;
29407 wxWindow *arg1 = (wxWindow *) 0 ;
29408 PyObject * obj0 = 0 ;
29409 char *kwnames[] = {
29410 (char *) "self", NULL
29411 };
29412
29413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29415 if (SWIG_arg_fail(1)) SWIG_fail;
29416 {
29417 PyThreadState* __tstate = wxPyBeginAllowThreads();
29418 (arg1)->Thaw();
29419
29420 wxPyEndAllowThreads(__tstate);
29421 if (PyErr_Occurred()) SWIG_fail;
29422 }
29423 Py_INCREF(Py_None); resultobj = Py_None;
29424 return resultobj;
29425 fail:
29426 return NULL;
29427 }
29428
29429
29430 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29431 PyObject *resultobj;
29432 wxWindow *arg1 = (wxWindow *) 0 ;
29433 wxDC *arg2 = 0 ;
29434 PyObject * obj0 = 0 ;
29435 PyObject * obj1 = 0 ;
29436 char *kwnames[] = {
29437 (char *) "self",(char *) "dc", NULL
29438 };
29439
29440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29442 if (SWIG_arg_fail(1)) SWIG_fail;
29443 {
29444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29445 if (SWIG_arg_fail(2)) SWIG_fail;
29446 if (arg2 == NULL) {
29447 SWIG_null_ref("wxDC");
29448 }
29449 if (SWIG_arg_fail(2)) SWIG_fail;
29450 }
29451 {
29452 PyThreadState* __tstate = wxPyBeginAllowThreads();
29453 (arg1)->PrepareDC(*arg2);
29454
29455 wxPyEndAllowThreads(__tstate);
29456 if (PyErr_Occurred()) SWIG_fail;
29457 }
29458 Py_INCREF(Py_None); resultobj = Py_None;
29459 return resultobj;
29460 fail:
29461 return NULL;
29462 }
29463
29464
29465 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29466 PyObject *resultobj;
29467 wxWindow *arg1 = (wxWindow *) 0 ;
29468 wxRegion *result;
29469 PyObject * obj0 = 0 ;
29470 char *kwnames[] = {
29471 (char *) "self", NULL
29472 };
29473
29474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29476 if (SWIG_arg_fail(1)) SWIG_fail;
29477 {
29478 PyThreadState* __tstate = wxPyBeginAllowThreads();
29479 {
29480 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29481 result = (wxRegion *) &_result_ref;
29482 }
29483
29484 wxPyEndAllowThreads(__tstate);
29485 if (PyErr_Occurred()) SWIG_fail;
29486 }
29487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29488 return resultobj;
29489 fail:
29490 return NULL;
29491 }
29492
29493
29494 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29495 PyObject *resultobj;
29496 wxWindow *arg1 = (wxWindow *) 0 ;
29497 wxRect result;
29498 PyObject * obj0 = 0 ;
29499 char *kwnames[] = {
29500 (char *) "self", NULL
29501 };
29502
29503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29505 if (SWIG_arg_fail(1)) SWIG_fail;
29506 {
29507 PyThreadState* __tstate = wxPyBeginAllowThreads();
29508 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29509
29510 wxPyEndAllowThreads(__tstate);
29511 if (PyErr_Occurred()) SWIG_fail;
29512 }
29513 {
29514 wxRect * resultptr;
29515 resultptr = new wxRect((wxRect &)(result));
29516 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29517 }
29518 return resultobj;
29519 fail:
29520 return NULL;
29521 }
29522
29523
29524 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29525 PyObject *resultobj;
29526 wxWindow *arg1 = (wxWindow *) 0 ;
29527 int arg2 ;
29528 int arg3 ;
29529 int arg4 = (int) 1 ;
29530 int arg5 = (int) 1 ;
29531 bool result;
29532 PyObject * obj0 = 0 ;
29533 PyObject * obj1 = 0 ;
29534 PyObject * obj2 = 0 ;
29535 PyObject * obj3 = 0 ;
29536 PyObject * obj4 = 0 ;
29537 char *kwnames[] = {
29538 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29539 };
29540
29541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29543 if (SWIG_arg_fail(1)) SWIG_fail;
29544 {
29545 arg2 = (int)(SWIG_As_int(obj1));
29546 if (SWIG_arg_fail(2)) SWIG_fail;
29547 }
29548 {
29549 arg3 = (int)(SWIG_As_int(obj2));
29550 if (SWIG_arg_fail(3)) SWIG_fail;
29551 }
29552 if (obj3) {
29553 {
29554 arg4 = (int)(SWIG_As_int(obj3));
29555 if (SWIG_arg_fail(4)) SWIG_fail;
29556 }
29557 }
29558 if (obj4) {
29559 {
29560 arg5 = (int)(SWIG_As_int(obj4));
29561 if (SWIG_arg_fail(5)) SWIG_fail;
29562 }
29563 }
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29567
29568 wxPyEndAllowThreads(__tstate);
29569 if (PyErr_Occurred()) SWIG_fail;
29570 }
29571 {
29572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29573 }
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29581 PyObject *resultobj;
29582 wxWindow *arg1 = (wxWindow *) 0 ;
29583 wxPoint *arg2 = 0 ;
29584 bool result;
29585 wxPoint temp2 ;
29586 PyObject * obj0 = 0 ;
29587 PyObject * obj1 = 0 ;
29588 char *kwnames[] = {
29589 (char *) "self",(char *) "pt", NULL
29590 };
29591
29592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29594 if (SWIG_arg_fail(1)) SWIG_fail;
29595 {
29596 arg2 = &temp2;
29597 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29598 }
29599 {
29600 PyThreadState* __tstate = wxPyBeginAllowThreads();
29601 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29602
29603 wxPyEndAllowThreads(__tstate);
29604 if (PyErr_Occurred()) SWIG_fail;
29605 }
29606 {
29607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29608 }
29609 return resultobj;
29610 fail:
29611 return NULL;
29612 }
29613
29614
29615 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29616 PyObject *resultobj;
29617 wxWindow *arg1 = (wxWindow *) 0 ;
29618 wxRect *arg2 = 0 ;
29619 bool result;
29620 wxRect temp2 ;
29621 PyObject * obj0 = 0 ;
29622 PyObject * obj1 = 0 ;
29623 char *kwnames[] = {
29624 (char *) "self",(char *) "rect", NULL
29625 };
29626
29627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29629 if (SWIG_arg_fail(1)) SWIG_fail;
29630 {
29631 arg2 = &temp2;
29632 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29633 }
29634 {
29635 PyThreadState* __tstate = wxPyBeginAllowThreads();
29636 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29637
29638 wxPyEndAllowThreads(__tstate);
29639 if (PyErr_Occurred()) SWIG_fail;
29640 }
29641 {
29642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29643 }
29644 return resultobj;
29645 fail:
29646 return NULL;
29647 }
29648
29649
29650 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29651 PyObject *resultobj;
29652 wxWindow *arg1 = (wxWindow *) 0 ;
29653 wxVisualAttributes result;
29654 PyObject * obj0 = 0 ;
29655 char *kwnames[] = {
29656 (char *) "self", NULL
29657 };
29658
29659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29661 if (SWIG_arg_fail(1)) SWIG_fail;
29662 {
29663 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29665
29666 wxPyEndAllowThreads(__tstate);
29667 if (PyErr_Occurred()) SWIG_fail;
29668 }
29669 {
29670 wxVisualAttributes * resultptr;
29671 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29672 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29673 }
29674 return resultobj;
29675 fail:
29676 return NULL;
29677 }
29678
29679
29680 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29681 PyObject *resultobj;
29682 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29683 wxVisualAttributes result;
29684 PyObject * obj0 = 0 ;
29685 char *kwnames[] = {
29686 (char *) "variant", NULL
29687 };
29688
29689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29690 if (obj0) {
29691 {
29692 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29693 if (SWIG_arg_fail(1)) SWIG_fail;
29694 }
29695 }
29696 {
29697 if (!wxPyCheckForApp()) SWIG_fail;
29698 PyThreadState* __tstate = wxPyBeginAllowThreads();
29699 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29700
29701 wxPyEndAllowThreads(__tstate);
29702 if (PyErr_Occurred()) SWIG_fail;
29703 }
29704 {
29705 wxVisualAttributes * resultptr;
29706 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29707 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29708 }
29709 return resultobj;
29710 fail:
29711 return NULL;
29712 }
29713
29714
29715 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29716 PyObject *resultobj;
29717 wxWindow *arg1 = (wxWindow *) 0 ;
29718 wxColour *arg2 = 0 ;
29719 bool result;
29720 wxColour temp2 ;
29721 PyObject * obj0 = 0 ;
29722 PyObject * obj1 = 0 ;
29723 char *kwnames[] = {
29724 (char *) "self",(char *) "colour", NULL
29725 };
29726
29727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29729 if (SWIG_arg_fail(1)) SWIG_fail;
29730 {
29731 arg2 = &temp2;
29732 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29733 }
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29737
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 {
29742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29743 }
29744 return resultobj;
29745 fail:
29746 return NULL;
29747 }
29748
29749
29750 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29751 PyObject *resultobj;
29752 wxWindow *arg1 = (wxWindow *) 0 ;
29753 wxColour *arg2 = 0 ;
29754 wxColour temp2 ;
29755 PyObject * obj0 = 0 ;
29756 PyObject * obj1 = 0 ;
29757 char *kwnames[] = {
29758 (char *) "self",(char *) "colour", NULL
29759 };
29760
29761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29763 if (SWIG_arg_fail(1)) SWIG_fail;
29764 {
29765 arg2 = &temp2;
29766 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29767 }
29768 {
29769 PyThreadState* __tstate = wxPyBeginAllowThreads();
29770 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29771
29772 wxPyEndAllowThreads(__tstate);
29773 if (PyErr_Occurred()) SWIG_fail;
29774 }
29775 Py_INCREF(Py_None); resultobj = Py_None;
29776 return resultobj;
29777 fail:
29778 return NULL;
29779 }
29780
29781
29782 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29783 PyObject *resultobj;
29784 wxWindow *arg1 = (wxWindow *) 0 ;
29785 wxColour *arg2 = 0 ;
29786 bool result;
29787 wxColour temp2 ;
29788 PyObject * obj0 = 0 ;
29789 PyObject * obj1 = 0 ;
29790 char *kwnames[] = {
29791 (char *) "self",(char *) "colour", NULL
29792 };
29793
29794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29796 if (SWIG_arg_fail(1)) SWIG_fail;
29797 {
29798 arg2 = &temp2;
29799 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29800 }
29801 {
29802 PyThreadState* __tstate = wxPyBeginAllowThreads();
29803 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29804
29805 wxPyEndAllowThreads(__tstate);
29806 if (PyErr_Occurred()) SWIG_fail;
29807 }
29808 {
29809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29810 }
29811 return resultobj;
29812 fail:
29813 return NULL;
29814 }
29815
29816
29817 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29818 PyObject *resultobj;
29819 wxWindow *arg1 = (wxWindow *) 0 ;
29820 wxColour *arg2 = 0 ;
29821 wxColour temp2 ;
29822 PyObject * obj0 = 0 ;
29823 PyObject * obj1 = 0 ;
29824 char *kwnames[] = {
29825 (char *) "self",(char *) "colour", NULL
29826 };
29827
29828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29830 if (SWIG_arg_fail(1)) SWIG_fail;
29831 {
29832 arg2 = &temp2;
29833 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29834 }
29835 {
29836 PyThreadState* __tstate = wxPyBeginAllowThreads();
29837 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29838
29839 wxPyEndAllowThreads(__tstate);
29840 if (PyErr_Occurred()) SWIG_fail;
29841 }
29842 Py_INCREF(Py_None); resultobj = Py_None;
29843 return resultobj;
29844 fail:
29845 return NULL;
29846 }
29847
29848
29849 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29850 PyObject *resultobj;
29851 wxWindow *arg1 = (wxWindow *) 0 ;
29852 wxColour result;
29853 PyObject * obj0 = 0 ;
29854 char *kwnames[] = {
29855 (char *) "self", NULL
29856 };
29857
29858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29860 if (SWIG_arg_fail(1)) SWIG_fail;
29861 {
29862 PyThreadState* __tstate = wxPyBeginAllowThreads();
29863 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29864
29865 wxPyEndAllowThreads(__tstate);
29866 if (PyErr_Occurred()) SWIG_fail;
29867 }
29868 {
29869 wxColour * resultptr;
29870 resultptr = new wxColour((wxColour &)(result));
29871 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29872 }
29873 return resultobj;
29874 fail:
29875 return NULL;
29876 }
29877
29878
29879 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29880 PyObject *resultobj;
29881 wxWindow *arg1 = (wxWindow *) 0 ;
29882 wxColour result;
29883 PyObject * obj0 = 0 ;
29884 char *kwnames[] = {
29885 (char *) "self", NULL
29886 };
29887
29888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29890 if (SWIG_arg_fail(1)) SWIG_fail;
29891 {
29892 PyThreadState* __tstate = wxPyBeginAllowThreads();
29893 result = ((wxWindow const *)arg1)->GetForegroundColour();
29894
29895 wxPyEndAllowThreads(__tstate);
29896 if (PyErr_Occurred()) SWIG_fail;
29897 }
29898 {
29899 wxColour * resultptr;
29900 resultptr = new wxColour((wxColour &)(result));
29901 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29902 }
29903 return resultobj;
29904 fail:
29905 return NULL;
29906 }
29907
29908
29909 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29910 PyObject *resultobj;
29911 wxWindow *arg1 = (wxWindow *) 0 ;
29912 bool result;
29913 PyObject * obj0 = 0 ;
29914 char *kwnames[] = {
29915 (char *) "self", NULL
29916 };
29917
29918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29920 if (SWIG_arg_fail(1)) SWIG_fail;
29921 {
29922 PyThreadState* __tstate = wxPyBeginAllowThreads();
29923 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29924
29925 wxPyEndAllowThreads(__tstate);
29926 if (PyErr_Occurred()) SWIG_fail;
29927 }
29928 {
29929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29930 }
29931 return resultobj;
29932 fail:
29933 return NULL;
29934 }
29935
29936
29937 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29938 PyObject *resultobj;
29939 wxWindow *arg1 = (wxWindow *) 0 ;
29940 bool result;
29941 PyObject * obj0 = 0 ;
29942 char *kwnames[] = {
29943 (char *) "self", NULL
29944 };
29945
29946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29948 if (SWIG_arg_fail(1)) SWIG_fail;
29949 {
29950 PyThreadState* __tstate = wxPyBeginAllowThreads();
29951 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29952
29953 wxPyEndAllowThreads(__tstate);
29954 if (PyErr_Occurred()) SWIG_fail;
29955 }
29956 {
29957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29958 }
29959 return resultobj;
29960 fail:
29961 return NULL;
29962 }
29963
29964
29965 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29966 PyObject *resultobj;
29967 wxWindow *arg1 = (wxWindow *) 0 ;
29968 wxBackgroundStyle arg2 ;
29969 bool result;
29970 PyObject * obj0 = 0 ;
29971 PyObject * obj1 = 0 ;
29972 char *kwnames[] = {
29973 (char *) "self",(char *) "style", NULL
29974 };
29975
29976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29978 if (SWIG_arg_fail(1)) SWIG_fail;
29979 {
29980 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29981 if (SWIG_arg_fail(2)) SWIG_fail;
29982 }
29983 {
29984 PyThreadState* __tstate = wxPyBeginAllowThreads();
29985 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29986
29987 wxPyEndAllowThreads(__tstate);
29988 if (PyErr_Occurred()) SWIG_fail;
29989 }
29990 {
29991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29992 }
29993 return resultobj;
29994 fail:
29995 return NULL;
29996 }
29997
29998
29999 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30000 PyObject *resultobj;
30001 wxWindow *arg1 = (wxWindow *) 0 ;
30002 wxBackgroundStyle result;
30003 PyObject * obj0 = 0 ;
30004 char *kwnames[] = {
30005 (char *) "self", NULL
30006 };
30007
30008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30010 if (SWIG_arg_fail(1)) SWIG_fail;
30011 {
30012 PyThreadState* __tstate = wxPyBeginAllowThreads();
30013 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30014
30015 wxPyEndAllowThreads(__tstate);
30016 if (PyErr_Occurred()) SWIG_fail;
30017 }
30018 resultobj = SWIG_From_int((result));
30019 return resultobj;
30020 fail:
30021 return NULL;
30022 }
30023
30024
30025 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30026 PyObject *resultobj;
30027 wxWindow *arg1 = (wxWindow *) 0 ;
30028 bool result;
30029 PyObject * obj0 = 0 ;
30030 char *kwnames[] = {
30031 (char *) "self", NULL
30032 };
30033
30034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30036 if (SWIG_arg_fail(1)) SWIG_fail;
30037 {
30038 PyThreadState* __tstate = wxPyBeginAllowThreads();
30039 result = (bool)(arg1)->HasTransparentBackground();
30040
30041 wxPyEndAllowThreads(__tstate);
30042 if (PyErr_Occurred()) SWIG_fail;
30043 }
30044 {
30045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30046 }
30047 return resultobj;
30048 fail:
30049 return NULL;
30050 }
30051
30052
30053 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30054 PyObject *resultobj;
30055 wxWindow *arg1 = (wxWindow *) 0 ;
30056 wxCursor *arg2 = 0 ;
30057 bool result;
30058 PyObject * obj0 = 0 ;
30059 PyObject * obj1 = 0 ;
30060 char *kwnames[] = {
30061 (char *) "self",(char *) "cursor", NULL
30062 };
30063
30064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30069 if (SWIG_arg_fail(2)) SWIG_fail;
30070 if (arg2 == NULL) {
30071 SWIG_null_ref("wxCursor");
30072 }
30073 if (SWIG_arg_fail(2)) SWIG_fail;
30074 }
30075 {
30076 PyThreadState* __tstate = wxPyBeginAllowThreads();
30077 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30078
30079 wxPyEndAllowThreads(__tstate);
30080 if (PyErr_Occurred()) SWIG_fail;
30081 }
30082 {
30083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30084 }
30085 return resultobj;
30086 fail:
30087 return NULL;
30088 }
30089
30090
30091 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30092 PyObject *resultobj;
30093 wxWindow *arg1 = (wxWindow *) 0 ;
30094 wxCursor result;
30095 PyObject * obj0 = 0 ;
30096 char *kwnames[] = {
30097 (char *) "self", NULL
30098 };
30099
30100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30102 if (SWIG_arg_fail(1)) SWIG_fail;
30103 {
30104 PyThreadState* __tstate = wxPyBeginAllowThreads();
30105 result = (arg1)->GetCursor();
30106
30107 wxPyEndAllowThreads(__tstate);
30108 if (PyErr_Occurred()) SWIG_fail;
30109 }
30110 {
30111 wxCursor * resultptr;
30112 resultptr = new wxCursor((wxCursor &)(result));
30113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30114 }
30115 return resultobj;
30116 fail:
30117 return NULL;
30118 }
30119
30120
30121 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30122 PyObject *resultobj;
30123 wxWindow *arg1 = (wxWindow *) 0 ;
30124 wxFont *arg2 = 0 ;
30125 bool result;
30126 PyObject * obj0 = 0 ;
30127 PyObject * obj1 = 0 ;
30128 char *kwnames[] = {
30129 (char *) "self",(char *) "font", NULL
30130 };
30131
30132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30134 if (SWIG_arg_fail(1)) SWIG_fail;
30135 {
30136 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30137 if (SWIG_arg_fail(2)) SWIG_fail;
30138 if (arg2 == NULL) {
30139 SWIG_null_ref("wxFont");
30140 }
30141 if (SWIG_arg_fail(2)) SWIG_fail;
30142 }
30143 {
30144 PyThreadState* __tstate = wxPyBeginAllowThreads();
30145 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30146
30147 wxPyEndAllowThreads(__tstate);
30148 if (PyErr_Occurred()) SWIG_fail;
30149 }
30150 {
30151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30152 }
30153 return resultobj;
30154 fail:
30155 return NULL;
30156 }
30157
30158
30159 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30160 PyObject *resultobj;
30161 wxWindow *arg1 = (wxWindow *) 0 ;
30162 wxFont *arg2 = 0 ;
30163 PyObject * obj0 = 0 ;
30164 PyObject * obj1 = 0 ;
30165 char *kwnames[] = {
30166 (char *) "self",(char *) "font", NULL
30167 };
30168
30169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30171 if (SWIG_arg_fail(1)) SWIG_fail;
30172 {
30173 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30174 if (SWIG_arg_fail(2)) SWIG_fail;
30175 if (arg2 == NULL) {
30176 SWIG_null_ref("wxFont");
30177 }
30178 if (SWIG_arg_fail(2)) SWIG_fail;
30179 }
30180 {
30181 PyThreadState* __tstate = wxPyBeginAllowThreads();
30182 (arg1)->SetOwnFont((wxFont const &)*arg2);
30183
30184 wxPyEndAllowThreads(__tstate);
30185 if (PyErr_Occurred()) SWIG_fail;
30186 }
30187 Py_INCREF(Py_None); resultobj = Py_None;
30188 return resultobj;
30189 fail:
30190 return NULL;
30191 }
30192
30193
30194 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30195 PyObject *resultobj;
30196 wxWindow *arg1 = (wxWindow *) 0 ;
30197 wxFont result;
30198 PyObject * obj0 = 0 ;
30199 char *kwnames[] = {
30200 (char *) "self", NULL
30201 };
30202
30203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30205 if (SWIG_arg_fail(1)) SWIG_fail;
30206 {
30207 PyThreadState* __tstate = wxPyBeginAllowThreads();
30208 result = (arg1)->GetFont();
30209
30210 wxPyEndAllowThreads(__tstate);
30211 if (PyErr_Occurred()) SWIG_fail;
30212 }
30213 {
30214 wxFont * resultptr;
30215 resultptr = new wxFont((wxFont &)(result));
30216 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30217 }
30218 return resultobj;
30219 fail:
30220 return NULL;
30221 }
30222
30223
30224 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30225 PyObject *resultobj;
30226 wxWindow *arg1 = (wxWindow *) 0 ;
30227 wxCaret *arg2 = (wxCaret *) 0 ;
30228 PyObject * obj0 = 0 ;
30229 PyObject * obj1 = 0 ;
30230 char *kwnames[] = {
30231 (char *) "self",(char *) "caret", NULL
30232 };
30233
30234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30236 if (SWIG_arg_fail(1)) SWIG_fail;
30237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30238 if (SWIG_arg_fail(2)) SWIG_fail;
30239 {
30240 PyThreadState* __tstate = wxPyBeginAllowThreads();
30241 (arg1)->SetCaret(arg2);
30242
30243 wxPyEndAllowThreads(__tstate);
30244 if (PyErr_Occurred()) SWIG_fail;
30245 }
30246 Py_INCREF(Py_None); resultobj = Py_None;
30247 return resultobj;
30248 fail:
30249 return NULL;
30250 }
30251
30252
30253 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30254 PyObject *resultobj;
30255 wxWindow *arg1 = (wxWindow *) 0 ;
30256 wxCaret *result;
30257 PyObject * obj0 = 0 ;
30258 char *kwnames[] = {
30259 (char *) "self", NULL
30260 };
30261
30262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30264 if (SWIG_arg_fail(1)) SWIG_fail;
30265 {
30266 PyThreadState* __tstate = wxPyBeginAllowThreads();
30267 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30268
30269 wxPyEndAllowThreads(__tstate);
30270 if (PyErr_Occurred()) SWIG_fail;
30271 }
30272 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30273 return resultobj;
30274 fail:
30275 return NULL;
30276 }
30277
30278
30279 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30280 PyObject *resultobj;
30281 wxWindow *arg1 = (wxWindow *) 0 ;
30282 int result;
30283 PyObject * obj0 = 0 ;
30284 char *kwnames[] = {
30285 (char *) "self", NULL
30286 };
30287
30288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30290 if (SWIG_arg_fail(1)) SWIG_fail;
30291 {
30292 PyThreadState* __tstate = wxPyBeginAllowThreads();
30293 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30294
30295 wxPyEndAllowThreads(__tstate);
30296 if (PyErr_Occurred()) SWIG_fail;
30297 }
30298 {
30299 resultobj = SWIG_From_int((int)(result));
30300 }
30301 return resultobj;
30302 fail:
30303 return NULL;
30304 }
30305
30306
30307 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30308 PyObject *resultobj;
30309 wxWindow *arg1 = (wxWindow *) 0 ;
30310 int result;
30311 PyObject * obj0 = 0 ;
30312 char *kwnames[] = {
30313 (char *) "self", NULL
30314 };
30315
30316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30318 if (SWIG_arg_fail(1)) SWIG_fail;
30319 {
30320 PyThreadState* __tstate = wxPyBeginAllowThreads();
30321 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30322
30323 wxPyEndAllowThreads(__tstate);
30324 if (PyErr_Occurred()) SWIG_fail;
30325 }
30326 {
30327 resultobj = SWIG_From_int((int)(result));
30328 }
30329 return resultobj;
30330 fail:
30331 return NULL;
30332 }
30333
30334
30335 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30336 PyObject *resultobj;
30337 wxWindow *arg1 = (wxWindow *) 0 ;
30338 wxString *arg2 = 0 ;
30339 int *arg3 = (int *) 0 ;
30340 int *arg4 = (int *) 0 ;
30341 bool temp2 = false ;
30342 int temp3 ;
30343 int res3 = 0 ;
30344 int temp4 ;
30345 int res4 = 0 ;
30346 PyObject * obj0 = 0 ;
30347 PyObject * obj1 = 0 ;
30348 char *kwnames[] = {
30349 (char *) "self",(char *) "string", NULL
30350 };
30351
30352 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30353 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30356 if (SWIG_arg_fail(1)) SWIG_fail;
30357 {
30358 arg2 = wxString_in_helper(obj1);
30359 if (arg2 == NULL) SWIG_fail;
30360 temp2 = true;
30361 }
30362 {
30363 PyThreadState* __tstate = wxPyBeginAllowThreads();
30364 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30365
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 Py_INCREF(Py_None); resultobj = Py_None;
30370 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30371 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30372 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30373 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30374 {
30375 if (temp2)
30376 delete arg2;
30377 }
30378 return resultobj;
30379 fail:
30380 {
30381 if (temp2)
30382 delete arg2;
30383 }
30384 return NULL;
30385 }
30386
30387
30388 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30389 PyObject *resultobj;
30390 wxWindow *arg1 = (wxWindow *) 0 ;
30391 wxString *arg2 = 0 ;
30392 int *arg3 = (int *) 0 ;
30393 int *arg4 = (int *) 0 ;
30394 int *arg5 = (int *) 0 ;
30395 int *arg6 = (int *) 0 ;
30396 wxFont *arg7 = (wxFont *) NULL ;
30397 bool temp2 = false ;
30398 int temp3 ;
30399 int res3 = 0 ;
30400 int temp4 ;
30401 int res4 = 0 ;
30402 int temp5 ;
30403 int res5 = 0 ;
30404 int temp6 ;
30405 int res6 = 0 ;
30406 PyObject * obj0 = 0 ;
30407 PyObject * obj1 = 0 ;
30408 PyObject * obj2 = 0 ;
30409 char *kwnames[] = {
30410 (char *) "self",(char *) "string",(char *) "font", NULL
30411 };
30412
30413 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30414 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30415 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30416 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30419 if (SWIG_arg_fail(1)) SWIG_fail;
30420 {
30421 arg2 = wxString_in_helper(obj1);
30422 if (arg2 == NULL) SWIG_fail;
30423 temp2 = true;
30424 }
30425 if (obj2) {
30426 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30427 if (SWIG_arg_fail(7)) SWIG_fail;
30428 }
30429 {
30430 PyThreadState* __tstate = wxPyBeginAllowThreads();
30431 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30432
30433 wxPyEndAllowThreads(__tstate);
30434 if (PyErr_Occurred()) SWIG_fail;
30435 }
30436 Py_INCREF(Py_None); resultobj = Py_None;
30437 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30438 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30439 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30440 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30441 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30442 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30443 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30444 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30445 {
30446 if (temp2)
30447 delete arg2;
30448 }
30449 return resultobj;
30450 fail:
30451 {
30452 if (temp2)
30453 delete arg2;
30454 }
30455 return NULL;
30456 }
30457
30458
30459 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30460 PyObject *resultobj;
30461 wxWindow *arg1 = (wxWindow *) 0 ;
30462 int *arg2 = (int *) 0 ;
30463 int *arg3 = (int *) 0 ;
30464 int temp2 ;
30465 int res2 = 0 ;
30466 int temp3 ;
30467 int res3 = 0 ;
30468 PyObject * obj0 = 0 ;
30469 PyObject * obj1 = 0 ;
30470 PyObject * obj2 = 0 ;
30471 char *kwnames[] = {
30472 (char *) "self",(char *) "x",(char *) "y", NULL
30473 };
30474
30475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30477 if (SWIG_arg_fail(1)) SWIG_fail;
30478 {
30479 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30480 temp2 = SWIG_As_int(obj1);
30481 if (SWIG_arg_fail(2)) SWIG_fail;
30482 arg2 = &temp2;
30483 res2 = SWIG_NEWOBJ;
30484 }
30485 }
30486 {
30487 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30488 temp3 = SWIG_As_int(obj2);
30489 if (SWIG_arg_fail(3)) SWIG_fail;
30490 arg3 = &temp3;
30491 res3 = SWIG_NEWOBJ;
30492 }
30493 }
30494 {
30495 PyThreadState* __tstate = wxPyBeginAllowThreads();
30496 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30497
30498 wxPyEndAllowThreads(__tstate);
30499 if (PyErr_Occurred()) SWIG_fail;
30500 }
30501 Py_INCREF(Py_None); resultobj = Py_None;
30502 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30503 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30504 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30505 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30506 return resultobj;
30507 fail:
30508 return NULL;
30509 }
30510
30511
30512 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30513 PyObject *resultobj;
30514 wxWindow *arg1 = (wxWindow *) 0 ;
30515 int *arg2 = (int *) 0 ;
30516 int *arg3 = (int *) 0 ;
30517 int temp2 ;
30518 int res2 = 0 ;
30519 int temp3 ;
30520 int res3 = 0 ;
30521 PyObject * obj0 = 0 ;
30522 PyObject * obj1 = 0 ;
30523 PyObject * obj2 = 0 ;
30524 char *kwnames[] = {
30525 (char *) "self",(char *) "x",(char *) "y", NULL
30526 };
30527
30528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30530 if (SWIG_arg_fail(1)) SWIG_fail;
30531 {
30532 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30533 temp2 = SWIG_As_int(obj1);
30534 if (SWIG_arg_fail(2)) SWIG_fail;
30535 arg2 = &temp2;
30536 res2 = SWIG_NEWOBJ;
30537 }
30538 }
30539 {
30540 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30541 temp3 = SWIG_As_int(obj2);
30542 if (SWIG_arg_fail(3)) SWIG_fail;
30543 arg3 = &temp3;
30544 res3 = SWIG_NEWOBJ;
30545 }
30546 }
30547 {
30548 PyThreadState* __tstate = wxPyBeginAllowThreads();
30549 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30550
30551 wxPyEndAllowThreads(__tstate);
30552 if (PyErr_Occurred()) SWIG_fail;
30553 }
30554 Py_INCREF(Py_None); resultobj = Py_None;
30555 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30556 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30557 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30558 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30559 return resultobj;
30560 fail:
30561 return NULL;
30562 }
30563
30564
30565 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30566 PyObject *resultobj;
30567 wxWindow *arg1 = (wxWindow *) 0 ;
30568 wxPoint *arg2 = 0 ;
30569 wxPoint result;
30570 wxPoint temp2 ;
30571 PyObject * obj0 = 0 ;
30572 PyObject * obj1 = 0 ;
30573 char *kwnames[] = {
30574 (char *) "self",(char *) "pt", NULL
30575 };
30576
30577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30579 if (SWIG_arg_fail(1)) SWIG_fail;
30580 {
30581 arg2 = &temp2;
30582 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30583 }
30584 {
30585 PyThreadState* __tstate = wxPyBeginAllowThreads();
30586 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30587
30588 wxPyEndAllowThreads(__tstate);
30589 if (PyErr_Occurred()) SWIG_fail;
30590 }
30591 {
30592 wxPoint * resultptr;
30593 resultptr = new wxPoint((wxPoint &)(result));
30594 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30595 }
30596 return resultobj;
30597 fail:
30598 return NULL;
30599 }
30600
30601
30602 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30603 PyObject *resultobj;
30604 wxWindow *arg1 = (wxWindow *) 0 ;
30605 wxPoint *arg2 = 0 ;
30606 wxPoint result;
30607 wxPoint temp2 ;
30608 PyObject * obj0 = 0 ;
30609 PyObject * obj1 = 0 ;
30610 char *kwnames[] = {
30611 (char *) "self",(char *) "pt", NULL
30612 };
30613
30614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30616 if (SWIG_arg_fail(1)) SWIG_fail;
30617 {
30618 arg2 = &temp2;
30619 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30620 }
30621 {
30622 PyThreadState* __tstate = wxPyBeginAllowThreads();
30623 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30624
30625 wxPyEndAllowThreads(__tstate);
30626 if (PyErr_Occurred()) SWIG_fail;
30627 }
30628 {
30629 wxPoint * resultptr;
30630 resultptr = new wxPoint((wxPoint &)(result));
30631 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30632 }
30633 return resultobj;
30634 fail:
30635 return NULL;
30636 }
30637
30638
30639 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30640 PyObject *resultobj;
30641 wxWindow *arg1 = (wxWindow *) 0 ;
30642 int arg2 ;
30643 int arg3 ;
30644 wxHitTest result;
30645 PyObject * obj0 = 0 ;
30646 PyObject * obj1 = 0 ;
30647 PyObject * obj2 = 0 ;
30648 char *kwnames[] = {
30649 (char *) "self",(char *) "x",(char *) "y", NULL
30650 };
30651
30652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30654 if (SWIG_arg_fail(1)) SWIG_fail;
30655 {
30656 arg2 = (int)(SWIG_As_int(obj1));
30657 if (SWIG_arg_fail(2)) SWIG_fail;
30658 }
30659 {
30660 arg3 = (int)(SWIG_As_int(obj2));
30661 if (SWIG_arg_fail(3)) SWIG_fail;
30662 }
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30666
30667 wxPyEndAllowThreads(__tstate);
30668 if (PyErr_Occurred()) SWIG_fail;
30669 }
30670 resultobj = SWIG_From_int((result));
30671 return resultobj;
30672 fail:
30673 return NULL;
30674 }
30675
30676
30677 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30678 PyObject *resultobj;
30679 wxWindow *arg1 = (wxWindow *) 0 ;
30680 wxPoint *arg2 = 0 ;
30681 wxHitTest result;
30682 wxPoint temp2 ;
30683 PyObject * obj0 = 0 ;
30684 PyObject * obj1 = 0 ;
30685 char *kwnames[] = {
30686 (char *) "self",(char *) "pt", NULL
30687 };
30688
30689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30691 if (SWIG_arg_fail(1)) SWIG_fail;
30692 {
30693 arg2 = &temp2;
30694 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30695 }
30696 {
30697 PyThreadState* __tstate = wxPyBeginAllowThreads();
30698 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30699
30700 wxPyEndAllowThreads(__tstate);
30701 if (PyErr_Occurred()) SWIG_fail;
30702 }
30703 resultobj = SWIG_From_int((result));
30704 return resultobj;
30705 fail:
30706 return NULL;
30707 }
30708
30709
30710 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30711 PyObject *resultobj;
30712 wxWindow *arg1 = (wxWindow *) 0 ;
30713 long arg2 ;
30714 wxBorder result;
30715 PyObject * obj0 = 0 ;
30716 PyObject * obj1 = 0 ;
30717
30718 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30720 if (SWIG_arg_fail(1)) SWIG_fail;
30721 {
30722 arg2 = (long)(SWIG_As_long(obj1));
30723 if (SWIG_arg_fail(2)) SWIG_fail;
30724 }
30725 {
30726 PyThreadState* __tstate = wxPyBeginAllowThreads();
30727 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30728
30729 wxPyEndAllowThreads(__tstate);
30730 if (PyErr_Occurred()) SWIG_fail;
30731 }
30732 resultobj = SWIG_From_int((result));
30733 return resultobj;
30734 fail:
30735 return NULL;
30736 }
30737
30738
30739 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30740 PyObject *resultobj;
30741 wxWindow *arg1 = (wxWindow *) 0 ;
30742 wxBorder result;
30743 PyObject * obj0 = 0 ;
30744
30745 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30747 if (SWIG_arg_fail(1)) SWIG_fail;
30748 {
30749 PyThreadState* __tstate = wxPyBeginAllowThreads();
30750 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30751
30752 wxPyEndAllowThreads(__tstate);
30753 if (PyErr_Occurred()) SWIG_fail;
30754 }
30755 resultobj = SWIG_From_int((result));
30756 return resultobj;
30757 fail:
30758 return NULL;
30759 }
30760
30761
30762 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30763 int argc;
30764 PyObject *argv[3];
30765 int ii;
30766
30767 argc = PyObject_Length(args);
30768 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30769 argv[ii] = PyTuple_GetItem(args,ii);
30770 }
30771 if (argc == 1) {
30772 int _v;
30773 {
30774 void *ptr;
30775 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30776 _v = 0;
30777 PyErr_Clear();
30778 } else {
30779 _v = 1;
30780 }
30781 }
30782 if (_v) {
30783 return _wrap_Window_GetBorder__SWIG_1(self,args);
30784 }
30785 }
30786 if (argc == 2) {
30787 int _v;
30788 {
30789 void *ptr;
30790 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30791 _v = 0;
30792 PyErr_Clear();
30793 } else {
30794 _v = 1;
30795 }
30796 }
30797 if (_v) {
30798 _v = SWIG_Check_long(argv[1]);
30799 if (_v) {
30800 return _wrap_Window_GetBorder__SWIG_0(self,args);
30801 }
30802 }
30803 }
30804
30805 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30806 return NULL;
30807 }
30808
30809
30810 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30811 PyObject *resultobj;
30812 wxWindow *arg1 = (wxWindow *) 0 ;
30813 long arg2 = (long) wxUPDATE_UI_NONE ;
30814 PyObject * obj0 = 0 ;
30815 PyObject * obj1 = 0 ;
30816 char *kwnames[] = {
30817 (char *) "self",(char *) "flags", NULL
30818 };
30819
30820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30822 if (SWIG_arg_fail(1)) SWIG_fail;
30823 if (obj1) {
30824 {
30825 arg2 = (long)(SWIG_As_long(obj1));
30826 if (SWIG_arg_fail(2)) SWIG_fail;
30827 }
30828 }
30829 {
30830 PyThreadState* __tstate = wxPyBeginAllowThreads();
30831 (arg1)->UpdateWindowUI(arg2);
30832
30833 wxPyEndAllowThreads(__tstate);
30834 if (PyErr_Occurred()) SWIG_fail;
30835 }
30836 Py_INCREF(Py_None); resultobj = Py_None;
30837 return resultobj;
30838 fail:
30839 return NULL;
30840 }
30841
30842
30843 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30844 PyObject *resultobj;
30845 wxWindow *arg1 = (wxWindow *) 0 ;
30846 wxMenu *arg2 = (wxMenu *) 0 ;
30847 int arg3 = (int) -1 ;
30848 int arg4 = (int) -1 ;
30849 bool result;
30850 PyObject * obj0 = 0 ;
30851 PyObject * obj1 = 0 ;
30852 PyObject * obj2 = 0 ;
30853 PyObject * obj3 = 0 ;
30854 char *kwnames[] = {
30855 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30856 };
30857
30858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30860 if (SWIG_arg_fail(1)) SWIG_fail;
30861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30862 if (SWIG_arg_fail(2)) SWIG_fail;
30863 if (obj2) {
30864 {
30865 arg3 = (int)(SWIG_As_int(obj2));
30866 if (SWIG_arg_fail(3)) SWIG_fail;
30867 }
30868 }
30869 if (obj3) {
30870 {
30871 arg4 = (int)(SWIG_As_int(obj3));
30872 if (SWIG_arg_fail(4)) SWIG_fail;
30873 }
30874 }
30875 {
30876 PyThreadState* __tstate = wxPyBeginAllowThreads();
30877 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30878
30879 wxPyEndAllowThreads(__tstate);
30880 if (PyErr_Occurred()) SWIG_fail;
30881 }
30882 {
30883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30884 }
30885 return resultobj;
30886 fail:
30887 return NULL;
30888 }
30889
30890
30891 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30892 PyObject *resultobj;
30893 wxWindow *arg1 = (wxWindow *) 0 ;
30894 wxMenu *arg2 = (wxMenu *) 0 ;
30895 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30896 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30897 bool result;
30898 wxPoint temp3 ;
30899 PyObject * obj0 = 0 ;
30900 PyObject * obj1 = 0 ;
30901 PyObject * obj2 = 0 ;
30902 char *kwnames[] = {
30903 (char *) "self",(char *) "menu",(char *) "pos", NULL
30904 };
30905
30906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30908 if (SWIG_arg_fail(1)) SWIG_fail;
30909 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30910 if (SWIG_arg_fail(2)) SWIG_fail;
30911 if (obj2) {
30912 {
30913 arg3 = &temp3;
30914 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30915 }
30916 }
30917 {
30918 PyThreadState* __tstate = wxPyBeginAllowThreads();
30919 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30920
30921 wxPyEndAllowThreads(__tstate);
30922 if (PyErr_Occurred()) SWIG_fail;
30923 }
30924 {
30925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30926 }
30927 return resultobj;
30928 fail:
30929 return NULL;
30930 }
30931
30932
30933 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30934 PyObject *resultobj;
30935 wxWindow *arg1 = (wxWindow *) 0 ;
30936 long result;
30937 PyObject * obj0 = 0 ;
30938 char *kwnames[] = {
30939 (char *) "self", NULL
30940 };
30941
30942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30944 if (SWIG_arg_fail(1)) SWIG_fail;
30945 {
30946 PyThreadState* __tstate = wxPyBeginAllowThreads();
30947 result = (long)wxWindow_GetHandle(arg1);
30948
30949 wxPyEndAllowThreads(__tstate);
30950 if (PyErr_Occurred()) SWIG_fail;
30951 }
30952 {
30953 resultobj = SWIG_From_long((long)(result));
30954 }
30955 return resultobj;
30956 fail:
30957 return NULL;
30958 }
30959
30960
30961 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30962 PyObject *resultobj;
30963 wxWindow *arg1 = (wxWindow *) 0 ;
30964 long arg2 ;
30965 PyObject * obj0 = 0 ;
30966 PyObject * obj1 = 0 ;
30967 char *kwnames[] = {
30968 (char *) "self",(char *) "handle", NULL
30969 };
30970
30971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30973 if (SWIG_arg_fail(1)) SWIG_fail;
30974 {
30975 arg2 = (long)(SWIG_As_long(obj1));
30976 if (SWIG_arg_fail(2)) SWIG_fail;
30977 }
30978 {
30979 PyThreadState* __tstate = wxPyBeginAllowThreads();
30980 wxWindow_AssociateHandle(arg1,arg2);
30981
30982 wxPyEndAllowThreads(__tstate);
30983 if (PyErr_Occurred()) SWIG_fail;
30984 }
30985 Py_INCREF(Py_None); resultobj = Py_None;
30986 return resultobj;
30987 fail:
30988 return NULL;
30989 }
30990
30991
30992 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30993 PyObject *resultobj;
30994 wxWindow *arg1 = (wxWindow *) 0 ;
30995 PyObject * obj0 = 0 ;
30996 char *kwnames[] = {
30997 (char *) "self", NULL
30998 };
30999
31000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31002 if (SWIG_arg_fail(1)) SWIG_fail;
31003 {
31004 PyThreadState* __tstate = wxPyBeginAllowThreads();
31005 (arg1)->DissociateHandle();
31006
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 Py_INCREF(Py_None); resultobj = Py_None;
31011 return resultobj;
31012 fail:
31013 return NULL;
31014 }
31015
31016
31017 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31018 PyObject *resultobj;
31019 wxWindow *arg1 = (wxWindow *) 0 ;
31020 int arg2 ;
31021 bool result;
31022 PyObject * obj0 = 0 ;
31023 PyObject * obj1 = 0 ;
31024 char *kwnames[] = {
31025 (char *) "self",(char *) "orient", NULL
31026 };
31027
31028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31030 if (SWIG_arg_fail(1)) SWIG_fail;
31031 {
31032 arg2 = (int)(SWIG_As_int(obj1));
31033 if (SWIG_arg_fail(2)) SWIG_fail;
31034 }
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31038
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 {
31043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31044 }
31045 return resultobj;
31046 fail:
31047 return NULL;
31048 }
31049
31050
31051 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31052 PyObject *resultobj;
31053 wxWindow *arg1 = (wxWindow *) 0 ;
31054 int arg2 ;
31055 int arg3 ;
31056 int arg4 ;
31057 int arg5 ;
31058 bool arg6 = (bool) true ;
31059 PyObject * obj0 = 0 ;
31060 PyObject * obj1 = 0 ;
31061 PyObject * obj2 = 0 ;
31062 PyObject * obj3 = 0 ;
31063 PyObject * obj4 = 0 ;
31064 PyObject * obj5 = 0 ;
31065 char *kwnames[] = {
31066 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31067 };
31068
31069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31071 if (SWIG_arg_fail(1)) SWIG_fail;
31072 {
31073 arg2 = (int)(SWIG_As_int(obj1));
31074 if (SWIG_arg_fail(2)) SWIG_fail;
31075 }
31076 {
31077 arg3 = (int)(SWIG_As_int(obj2));
31078 if (SWIG_arg_fail(3)) SWIG_fail;
31079 }
31080 {
31081 arg4 = (int)(SWIG_As_int(obj3));
31082 if (SWIG_arg_fail(4)) SWIG_fail;
31083 }
31084 {
31085 arg5 = (int)(SWIG_As_int(obj4));
31086 if (SWIG_arg_fail(5)) SWIG_fail;
31087 }
31088 if (obj5) {
31089 {
31090 arg6 = (bool)(SWIG_As_bool(obj5));
31091 if (SWIG_arg_fail(6)) SWIG_fail;
31092 }
31093 }
31094 {
31095 PyThreadState* __tstate = wxPyBeginAllowThreads();
31096 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31097
31098 wxPyEndAllowThreads(__tstate);
31099 if (PyErr_Occurred()) SWIG_fail;
31100 }
31101 Py_INCREF(Py_None); resultobj = Py_None;
31102 return resultobj;
31103 fail:
31104 return NULL;
31105 }
31106
31107
31108 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31109 PyObject *resultobj;
31110 wxWindow *arg1 = (wxWindow *) 0 ;
31111 int arg2 ;
31112 int arg3 ;
31113 bool arg4 = (bool) true ;
31114 PyObject * obj0 = 0 ;
31115 PyObject * obj1 = 0 ;
31116 PyObject * obj2 = 0 ;
31117 PyObject * obj3 = 0 ;
31118 char *kwnames[] = {
31119 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31120 };
31121
31122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31124 if (SWIG_arg_fail(1)) SWIG_fail;
31125 {
31126 arg2 = (int)(SWIG_As_int(obj1));
31127 if (SWIG_arg_fail(2)) SWIG_fail;
31128 }
31129 {
31130 arg3 = (int)(SWIG_As_int(obj2));
31131 if (SWIG_arg_fail(3)) SWIG_fail;
31132 }
31133 if (obj3) {
31134 {
31135 arg4 = (bool)(SWIG_As_bool(obj3));
31136 if (SWIG_arg_fail(4)) SWIG_fail;
31137 }
31138 }
31139 {
31140 PyThreadState* __tstate = wxPyBeginAllowThreads();
31141 (arg1)->SetScrollPos(arg2,arg3,arg4);
31142
31143 wxPyEndAllowThreads(__tstate);
31144 if (PyErr_Occurred()) SWIG_fail;
31145 }
31146 Py_INCREF(Py_None); resultobj = Py_None;
31147 return resultobj;
31148 fail:
31149 return NULL;
31150 }
31151
31152
31153 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31154 PyObject *resultobj;
31155 wxWindow *arg1 = (wxWindow *) 0 ;
31156 int arg2 ;
31157 int result;
31158 PyObject * obj0 = 0 ;
31159 PyObject * obj1 = 0 ;
31160 char *kwnames[] = {
31161 (char *) "self",(char *) "orientation", NULL
31162 };
31163
31164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31166 if (SWIG_arg_fail(1)) SWIG_fail;
31167 {
31168 arg2 = (int)(SWIG_As_int(obj1));
31169 if (SWIG_arg_fail(2)) SWIG_fail;
31170 }
31171 {
31172 PyThreadState* __tstate = wxPyBeginAllowThreads();
31173 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31174
31175 wxPyEndAllowThreads(__tstate);
31176 if (PyErr_Occurred()) SWIG_fail;
31177 }
31178 {
31179 resultobj = SWIG_From_int((int)(result));
31180 }
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31188 PyObject *resultobj;
31189 wxWindow *arg1 = (wxWindow *) 0 ;
31190 int arg2 ;
31191 int result;
31192 PyObject * obj0 = 0 ;
31193 PyObject * obj1 = 0 ;
31194 char *kwnames[] = {
31195 (char *) "self",(char *) "orientation", NULL
31196 };
31197
31198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31200 if (SWIG_arg_fail(1)) SWIG_fail;
31201 {
31202 arg2 = (int)(SWIG_As_int(obj1));
31203 if (SWIG_arg_fail(2)) SWIG_fail;
31204 }
31205 {
31206 PyThreadState* __tstate = wxPyBeginAllowThreads();
31207 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31208
31209 wxPyEndAllowThreads(__tstate);
31210 if (PyErr_Occurred()) SWIG_fail;
31211 }
31212 {
31213 resultobj = SWIG_From_int((int)(result));
31214 }
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31222 PyObject *resultobj;
31223 wxWindow *arg1 = (wxWindow *) 0 ;
31224 int arg2 ;
31225 int result;
31226 PyObject * obj0 = 0 ;
31227 PyObject * obj1 = 0 ;
31228 char *kwnames[] = {
31229 (char *) "self",(char *) "orientation", NULL
31230 };
31231
31232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31234 if (SWIG_arg_fail(1)) SWIG_fail;
31235 {
31236 arg2 = (int)(SWIG_As_int(obj1));
31237 if (SWIG_arg_fail(2)) SWIG_fail;
31238 }
31239 {
31240 PyThreadState* __tstate = wxPyBeginAllowThreads();
31241 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31242
31243 wxPyEndAllowThreads(__tstate);
31244 if (PyErr_Occurred()) SWIG_fail;
31245 }
31246 {
31247 resultobj = SWIG_From_int((int)(result));
31248 }
31249 return resultobj;
31250 fail:
31251 return NULL;
31252 }
31253
31254
31255 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31256 PyObject *resultobj;
31257 wxWindow *arg1 = (wxWindow *) 0 ;
31258 int arg2 ;
31259 int arg3 ;
31260 wxRect *arg4 = (wxRect *) NULL ;
31261 PyObject * obj0 = 0 ;
31262 PyObject * obj1 = 0 ;
31263 PyObject * obj2 = 0 ;
31264 PyObject * obj3 = 0 ;
31265 char *kwnames[] = {
31266 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31267 };
31268
31269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31271 if (SWIG_arg_fail(1)) SWIG_fail;
31272 {
31273 arg2 = (int)(SWIG_As_int(obj1));
31274 if (SWIG_arg_fail(2)) SWIG_fail;
31275 }
31276 {
31277 arg3 = (int)(SWIG_As_int(obj2));
31278 if (SWIG_arg_fail(3)) SWIG_fail;
31279 }
31280 if (obj3) {
31281 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31282 if (SWIG_arg_fail(4)) SWIG_fail;
31283 }
31284 {
31285 PyThreadState* __tstate = wxPyBeginAllowThreads();
31286 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31287
31288 wxPyEndAllowThreads(__tstate);
31289 if (PyErr_Occurred()) SWIG_fail;
31290 }
31291 Py_INCREF(Py_None); resultobj = Py_None;
31292 return resultobj;
31293 fail:
31294 return NULL;
31295 }
31296
31297
31298 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31299 PyObject *resultobj;
31300 wxWindow *arg1 = (wxWindow *) 0 ;
31301 int arg2 ;
31302 bool result;
31303 PyObject * obj0 = 0 ;
31304 PyObject * obj1 = 0 ;
31305 char *kwnames[] = {
31306 (char *) "self",(char *) "lines", NULL
31307 };
31308
31309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31311 if (SWIG_arg_fail(1)) SWIG_fail;
31312 {
31313 arg2 = (int)(SWIG_As_int(obj1));
31314 if (SWIG_arg_fail(2)) SWIG_fail;
31315 }
31316 {
31317 PyThreadState* __tstate = wxPyBeginAllowThreads();
31318 result = (bool)(arg1)->ScrollLines(arg2);
31319
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 {
31324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31325 }
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31333 PyObject *resultobj;
31334 wxWindow *arg1 = (wxWindow *) 0 ;
31335 int arg2 ;
31336 bool result;
31337 PyObject * obj0 = 0 ;
31338 PyObject * obj1 = 0 ;
31339 char *kwnames[] = {
31340 (char *) "self",(char *) "pages", NULL
31341 };
31342
31343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31345 if (SWIG_arg_fail(1)) SWIG_fail;
31346 {
31347 arg2 = (int)(SWIG_As_int(obj1));
31348 if (SWIG_arg_fail(2)) SWIG_fail;
31349 }
31350 {
31351 PyThreadState* __tstate = wxPyBeginAllowThreads();
31352 result = (bool)(arg1)->ScrollPages(arg2);
31353
31354 wxPyEndAllowThreads(__tstate);
31355 if (PyErr_Occurred()) SWIG_fail;
31356 }
31357 {
31358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31359 }
31360 return resultobj;
31361 fail:
31362 return NULL;
31363 }
31364
31365
31366 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31367 PyObject *resultobj;
31368 wxWindow *arg1 = (wxWindow *) 0 ;
31369 bool result;
31370 PyObject * obj0 = 0 ;
31371 char *kwnames[] = {
31372 (char *) "self", NULL
31373 };
31374
31375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31377 if (SWIG_arg_fail(1)) SWIG_fail;
31378 {
31379 PyThreadState* __tstate = wxPyBeginAllowThreads();
31380 result = (bool)(arg1)->LineUp();
31381
31382 wxPyEndAllowThreads(__tstate);
31383 if (PyErr_Occurred()) SWIG_fail;
31384 }
31385 {
31386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31387 }
31388 return resultobj;
31389 fail:
31390 return NULL;
31391 }
31392
31393
31394 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31395 PyObject *resultobj;
31396 wxWindow *arg1 = (wxWindow *) 0 ;
31397 bool result;
31398 PyObject * obj0 = 0 ;
31399 char *kwnames[] = {
31400 (char *) "self", NULL
31401 };
31402
31403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31405 if (SWIG_arg_fail(1)) SWIG_fail;
31406 {
31407 PyThreadState* __tstate = wxPyBeginAllowThreads();
31408 result = (bool)(arg1)->LineDown();
31409
31410 wxPyEndAllowThreads(__tstate);
31411 if (PyErr_Occurred()) SWIG_fail;
31412 }
31413 {
31414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31415 }
31416 return resultobj;
31417 fail:
31418 return NULL;
31419 }
31420
31421
31422 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31423 PyObject *resultobj;
31424 wxWindow *arg1 = (wxWindow *) 0 ;
31425 bool result;
31426 PyObject * obj0 = 0 ;
31427 char *kwnames[] = {
31428 (char *) "self", NULL
31429 };
31430
31431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31433 if (SWIG_arg_fail(1)) SWIG_fail;
31434 {
31435 PyThreadState* __tstate = wxPyBeginAllowThreads();
31436 result = (bool)(arg1)->PageUp();
31437
31438 wxPyEndAllowThreads(__tstate);
31439 if (PyErr_Occurred()) SWIG_fail;
31440 }
31441 {
31442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31443 }
31444 return resultobj;
31445 fail:
31446 return NULL;
31447 }
31448
31449
31450 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31451 PyObject *resultobj;
31452 wxWindow *arg1 = (wxWindow *) 0 ;
31453 bool result;
31454 PyObject * obj0 = 0 ;
31455 char *kwnames[] = {
31456 (char *) "self", NULL
31457 };
31458
31459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31461 if (SWIG_arg_fail(1)) SWIG_fail;
31462 {
31463 PyThreadState* __tstate = wxPyBeginAllowThreads();
31464 result = (bool)(arg1)->PageDown();
31465
31466 wxPyEndAllowThreads(__tstate);
31467 if (PyErr_Occurred()) SWIG_fail;
31468 }
31469 {
31470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31471 }
31472 return resultobj;
31473 fail:
31474 return NULL;
31475 }
31476
31477
31478 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31479 PyObject *resultobj;
31480 wxWindow *arg1 = (wxWindow *) 0 ;
31481 wxString *arg2 = 0 ;
31482 bool temp2 = false ;
31483 PyObject * obj0 = 0 ;
31484 PyObject * obj1 = 0 ;
31485 char *kwnames[] = {
31486 (char *) "self",(char *) "text", NULL
31487 };
31488
31489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31491 if (SWIG_arg_fail(1)) SWIG_fail;
31492 {
31493 arg2 = wxString_in_helper(obj1);
31494 if (arg2 == NULL) SWIG_fail;
31495 temp2 = true;
31496 }
31497 {
31498 PyThreadState* __tstate = wxPyBeginAllowThreads();
31499 (arg1)->SetHelpText((wxString const &)*arg2);
31500
31501 wxPyEndAllowThreads(__tstate);
31502 if (PyErr_Occurred()) SWIG_fail;
31503 }
31504 Py_INCREF(Py_None); resultobj = Py_None;
31505 {
31506 if (temp2)
31507 delete arg2;
31508 }
31509 return resultobj;
31510 fail:
31511 {
31512 if (temp2)
31513 delete arg2;
31514 }
31515 return NULL;
31516 }
31517
31518
31519 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31520 PyObject *resultobj;
31521 wxWindow *arg1 = (wxWindow *) 0 ;
31522 wxString *arg2 = 0 ;
31523 bool temp2 = false ;
31524 PyObject * obj0 = 0 ;
31525 PyObject * obj1 = 0 ;
31526 char *kwnames[] = {
31527 (char *) "self",(char *) "text", NULL
31528 };
31529
31530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31532 if (SWIG_arg_fail(1)) SWIG_fail;
31533 {
31534 arg2 = wxString_in_helper(obj1);
31535 if (arg2 == NULL) SWIG_fail;
31536 temp2 = true;
31537 }
31538 {
31539 PyThreadState* __tstate = wxPyBeginAllowThreads();
31540 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31541
31542 wxPyEndAllowThreads(__tstate);
31543 if (PyErr_Occurred()) SWIG_fail;
31544 }
31545 Py_INCREF(Py_None); resultobj = Py_None;
31546 {
31547 if (temp2)
31548 delete arg2;
31549 }
31550 return resultobj;
31551 fail:
31552 {
31553 if (temp2)
31554 delete arg2;
31555 }
31556 return NULL;
31557 }
31558
31559
31560 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31561 PyObject *resultobj;
31562 wxWindow *arg1 = (wxWindow *) 0 ;
31563 wxString result;
31564 PyObject * obj0 = 0 ;
31565 char *kwnames[] = {
31566 (char *) "self", NULL
31567 };
31568
31569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31571 if (SWIG_arg_fail(1)) SWIG_fail;
31572 {
31573 PyThreadState* __tstate = wxPyBeginAllowThreads();
31574 result = ((wxWindow const *)arg1)->GetHelpText();
31575
31576 wxPyEndAllowThreads(__tstate);
31577 if (PyErr_Occurred()) SWIG_fail;
31578 }
31579 {
31580 #if wxUSE_UNICODE
31581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31582 #else
31583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31584 #endif
31585 }
31586 return resultobj;
31587 fail:
31588 return NULL;
31589 }
31590
31591
31592 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31593 PyObject *resultobj;
31594 wxWindow *arg1 = (wxWindow *) 0 ;
31595 wxString *arg2 = 0 ;
31596 bool temp2 = false ;
31597 PyObject * obj0 = 0 ;
31598 PyObject * obj1 = 0 ;
31599 char *kwnames[] = {
31600 (char *) "self",(char *) "tip", NULL
31601 };
31602
31603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31605 if (SWIG_arg_fail(1)) SWIG_fail;
31606 {
31607 arg2 = wxString_in_helper(obj1);
31608 if (arg2 == NULL) SWIG_fail;
31609 temp2 = true;
31610 }
31611 {
31612 PyThreadState* __tstate = wxPyBeginAllowThreads();
31613 (arg1)->SetToolTip((wxString const &)*arg2);
31614
31615 wxPyEndAllowThreads(__tstate);
31616 if (PyErr_Occurred()) SWIG_fail;
31617 }
31618 Py_INCREF(Py_None); resultobj = Py_None;
31619 {
31620 if (temp2)
31621 delete arg2;
31622 }
31623 return resultobj;
31624 fail:
31625 {
31626 if (temp2)
31627 delete arg2;
31628 }
31629 return NULL;
31630 }
31631
31632
31633 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31634 PyObject *resultobj;
31635 wxWindow *arg1 = (wxWindow *) 0 ;
31636 wxToolTip *arg2 = (wxToolTip *) 0 ;
31637 PyObject * obj0 = 0 ;
31638 PyObject * obj1 = 0 ;
31639 char *kwnames[] = {
31640 (char *) "self",(char *) "tip", NULL
31641 };
31642
31643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31645 if (SWIG_arg_fail(1)) SWIG_fail;
31646 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31647 if (SWIG_arg_fail(2)) SWIG_fail;
31648 {
31649 PyThreadState* __tstate = wxPyBeginAllowThreads();
31650 (arg1)->SetToolTip(arg2);
31651
31652 wxPyEndAllowThreads(__tstate);
31653 if (PyErr_Occurred()) SWIG_fail;
31654 }
31655 Py_INCREF(Py_None); resultobj = Py_None;
31656 return resultobj;
31657 fail:
31658 return NULL;
31659 }
31660
31661
31662 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31663 PyObject *resultobj;
31664 wxWindow *arg1 = (wxWindow *) 0 ;
31665 wxToolTip *result;
31666 PyObject * obj0 = 0 ;
31667 char *kwnames[] = {
31668 (char *) "self", NULL
31669 };
31670
31671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31673 if (SWIG_arg_fail(1)) SWIG_fail;
31674 {
31675 PyThreadState* __tstate = wxPyBeginAllowThreads();
31676 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31677
31678 wxPyEndAllowThreads(__tstate);
31679 if (PyErr_Occurred()) SWIG_fail;
31680 }
31681 {
31682 resultobj = wxPyMake_wxObject(result, 0);
31683 }
31684 return resultobj;
31685 fail:
31686 return NULL;
31687 }
31688
31689
31690 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31691 PyObject *resultobj;
31692 wxWindow *arg1 = (wxWindow *) 0 ;
31693 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31694 PyObject * obj0 = 0 ;
31695 PyObject * obj1 = 0 ;
31696 char *kwnames[] = {
31697 (char *) "self",(char *) "dropTarget", NULL
31698 };
31699
31700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31702 if (SWIG_arg_fail(1)) SWIG_fail;
31703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31704 if (SWIG_arg_fail(2)) SWIG_fail;
31705 {
31706 PyThreadState* __tstate = wxPyBeginAllowThreads();
31707 (arg1)->SetDropTarget(arg2);
31708
31709 wxPyEndAllowThreads(__tstate);
31710 if (PyErr_Occurred()) SWIG_fail;
31711 }
31712 Py_INCREF(Py_None); resultobj = Py_None;
31713 return resultobj;
31714 fail:
31715 return NULL;
31716 }
31717
31718
31719 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31720 PyObject *resultobj;
31721 wxWindow *arg1 = (wxWindow *) 0 ;
31722 wxPyDropTarget *result;
31723 PyObject * obj0 = 0 ;
31724 char *kwnames[] = {
31725 (char *) "self", NULL
31726 };
31727
31728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31730 if (SWIG_arg_fail(1)) SWIG_fail;
31731 {
31732 PyThreadState* __tstate = wxPyBeginAllowThreads();
31733 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31734
31735 wxPyEndAllowThreads(__tstate);
31736 if (PyErr_Occurred()) SWIG_fail;
31737 }
31738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31739 return resultobj;
31740 fail:
31741 return NULL;
31742 }
31743
31744
31745 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31746 PyObject *resultobj;
31747 wxWindow *arg1 = (wxWindow *) 0 ;
31748 bool arg2 ;
31749 PyObject * obj0 = 0 ;
31750 PyObject * obj1 = 0 ;
31751 char *kwnames[] = {
31752 (char *) "self",(char *) "accept", NULL
31753 };
31754
31755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31757 if (SWIG_arg_fail(1)) SWIG_fail;
31758 {
31759 arg2 = (bool)(SWIG_As_bool(obj1));
31760 if (SWIG_arg_fail(2)) SWIG_fail;
31761 }
31762 {
31763 PyThreadState* __tstate = wxPyBeginAllowThreads();
31764 wxWindow_DragAcceptFiles(arg1,arg2);
31765
31766 wxPyEndAllowThreads(__tstate);
31767 if (PyErr_Occurred()) SWIG_fail;
31768 }
31769 Py_INCREF(Py_None); resultobj = Py_None;
31770 return resultobj;
31771 fail:
31772 return NULL;
31773 }
31774
31775
31776 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31777 PyObject *resultobj;
31778 wxWindow *arg1 = (wxWindow *) 0 ;
31779 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31780 PyObject * obj0 = 0 ;
31781 PyObject * obj1 = 0 ;
31782 char *kwnames[] = {
31783 (char *) "self",(char *) "constraints", NULL
31784 };
31785
31786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31788 if (SWIG_arg_fail(1)) SWIG_fail;
31789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31790 if (SWIG_arg_fail(2)) SWIG_fail;
31791 {
31792 PyThreadState* __tstate = wxPyBeginAllowThreads();
31793 (arg1)->SetConstraints(arg2);
31794
31795 wxPyEndAllowThreads(__tstate);
31796 if (PyErr_Occurred()) SWIG_fail;
31797 }
31798 Py_INCREF(Py_None); resultobj = Py_None;
31799 return resultobj;
31800 fail:
31801 return NULL;
31802 }
31803
31804
31805 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31806 PyObject *resultobj;
31807 wxWindow *arg1 = (wxWindow *) 0 ;
31808 wxLayoutConstraints *result;
31809 PyObject * obj0 = 0 ;
31810 char *kwnames[] = {
31811 (char *) "self", NULL
31812 };
31813
31814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31816 if (SWIG_arg_fail(1)) SWIG_fail;
31817 {
31818 PyThreadState* __tstate = wxPyBeginAllowThreads();
31819 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31820
31821 wxPyEndAllowThreads(__tstate);
31822 if (PyErr_Occurred()) SWIG_fail;
31823 }
31824 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31825 return resultobj;
31826 fail:
31827 return NULL;
31828 }
31829
31830
31831 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31832 PyObject *resultobj;
31833 wxWindow *arg1 = (wxWindow *) 0 ;
31834 bool arg2 ;
31835 PyObject * obj0 = 0 ;
31836 PyObject * obj1 = 0 ;
31837 char *kwnames[] = {
31838 (char *) "self",(char *) "autoLayout", NULL
31839 };
31840
31841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31843 if (SWIG_arg_fail(1)) SWIG_fail;
31844 {
31845 arg2 = (bool)(SWIG_As_bool(obj1));
31846 if (SWIG_arg_fail(2)) SWIG_fail;
31847 }
31848 {
31849 PyThreadState* __tstate = wxPyBeginAllowThreads();
31850 (arg1)->SetAutoLayout(arg2);
31851
31852 wxPyEndAllowThreads(__tstate);
31853 if (PyErr_Occurred()) SWIG_fail;
31854 }
31855 Py_INCREF(Py_None); resultobj = Py_None;
31856 return resultobj;
31857 fail:
31858 return NULL;
31859 }
31860
31861
31862 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31863 PyObject *resultobj;
31864 wxWindow *arg1 = (wxWindow *) 0 ;
31865 bool result;
31866 PyObject * obj0 = 0 ;
31867 char *kwnames[] = {
31868 (char *) "self", NULL
31869 };
31870
31871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31873 if (SWIG_arg_fail(1)) SWIG_fail;
31874 {
31875 PyThreadState* __tstate = wxPyBeginAllowThreads();
31876 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31877
31878 wxPyEndAllowThreads(__tstate);
31879 if (PyErr_Occurred()) SWIG_fail;
31880 }
31881 {
31882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31883 }
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31891 PyObject *resultobj;
31892 wxWindow *arg1 = (wxWindow *) 0 ;
31893 bool result;
31894 PyObject * obj0 = 0 ;
31895 char *kwnames[] = {
31896 (char *) "self", NULL
31897 };
31898
31899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31901 if (SWIG_arg_fail(1)) SWIG_fail;
31902 {
31903 PyThreadState* __tstate = wxPyBeginAllowThreads();
31904 result = (bool)(arg1)->Layout();
31905
31906 wxPyEndAllowThreads(__tstate);
31907 if (PyErr_Occurred()) SWIG_fail;
31908 }
31909 {
31910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31911 }
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31919 PyObject *resultobj;
31920 wxWindow *arg1 = (wxWindow *) 0 ;
31921 wxSizer *arg2 = (wxSizer *) 0 ;
31922 bool arg3 = (bool) true ;
31923 PyObject * obj0 = 0 ;
31924 PyObject * obj1 = 0 ;
31925 PyObject * obj2 = 0 ;
31926 char *kwnames[] = {
31927 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31928 };
31929
31930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31932 if (SWIG_arg_fail(1)) SWIG_fail;
31933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31934 if (SWIG_arg_fail(2)) SWIG_fail;
31935 if (obj2) {
31936 {
31937 arg3 = (bool)(SWIG_As_bool(obj2));
31938 if (SWIG_arg_fail(3)) SWIG_fail;
31939 }
31940 }
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 (arg1)->SetSizer(arg2,arg3);
31944
31945 wxPyEndAllowThreads(__tstate);
31946 if (PyErr_Occurred()) SWIG_fail;
31947 }
31948 Py_INCREF(Py_None); resultobj = Py_None;
31949 return resultobj;
31950 fail:
31951 return NULL;
31952 }
31953
31954
31955 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31956 PyObject *resultobj;
31957 wxWindow *arg1 = (wxWindow *) 0 ;
31958 wxSizer *arg2 = (wxSizer *) 0 ;
31959 bool arg3 = (bool) true ;
31960 PyObject * obj0 = 0 ;
31961 PyObject * obj1 = 0 ;
31962 PyObject * obj2 = 0 ;
31963 char *kwnames[] = {
31964 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31965 };
31966
31967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31969 if (SWIG_arg_fail(1)) SWIG_fail;
31970 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31971 if (SWIG_arg_fail(2)) SWIG_fail;
31972 if (obj2) {
31973 {
31974 arg3 = (bool)(SWIG_As_bool(obj2));
31975 if (SWIG_arg_fail(3)) SWIG_fail;
31976 }
31977 }
31978 {
31979 PyThreadState* __tstate = wxPyBeginAllowThreads();
31980 (arg1)->SetSizerAndFit(arg2,arg3);
31981
31982 wxPyEndAllowThreads(__tstate);
31983 if (PyErr_Occurred()) SWIG_fail;
31984 }
31985 Py_INCREF(Py_None); resultobj = Py_None;
31986 return resultobj;
31987 fail:
31988 return NULL;
31989 }
31990
31991
31992 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31993 PyObject *resultobj;
31994 wxWindow *arg1 = (wxWindow *) 0 ;
31995 wxSizer *result;
31996 PyObject * obj0 = 0 ;
31997 char *kwnames[] = {
31998 (char *) "self", NULL
31999 };
32000
32001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32003 if (SWIG_arg_fail(1)) SWIG_fail;
32004 {
32005 PyThreadState* __tstate = wxPyBeginAllowThreads();
32006 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32007
32008 wxPyEndAllowThreads(__tstate);
32009 if (PyErr_Occurred()) SWIG_fail;
32010 }
32011 {
32012 resultobj = wxPyMake_wxObject(result, 0);
32013 }
32014 return resultobj;
32015 fail:
32016 return NULL;
32017 }
32018
32019
32020 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32021 PyObject *resultobj;
32022 wxWindow *arg1 = (wxWindow *) 0 ;
32023 wxSizer *arg2 = (wxSizer *) 0 ;
32024 PyObject * obj0 = 0 ;
32025 PyObject * obj1 = 0 ;
32026 char *kwnames[] = {
32027 (char *) "self",(char *) "sizer", NULL
32028 };
32029
32030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32032 if (SWIG_arg_fail(1)) SWIG_fail;
32033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32034 if (SWIG_arg_fail(2)) SWIG_fail;
32035 {
32036 PyThreadState* __tstate = wxPyBeginAllowThreads();
32037 (arg1)->SetContainingSizer(arg2);
32038
32039 wxPyEndAllowThreads(__tstate);
32040 if (PyErr_Occurred()) SWIG_fail;
32041 }
32042 Py_INCREF(Py_None); resultobj = Py_None;
32043 return resultobj;
32044 fail:
32045 return NULL;
32046 }
32047
32048
32049 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32050 PyObject *resultobj;
32051 wxWindow *arg1 = (wxWindow *) 0 ;
32052 wxSizer *result;
32053 PyObject * obj0 = 0 ;
32054 char *kwnames[] = {
32055 (char *) "self", NULL
32056 };
32057
32058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32060 if (SWIG_arg_fail(1)) SWIG_fail;
32061 {
32062 PyThreadState* __tstate = wxPyBeginAllowThreads();
32063 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32064
32065 wxPyEndAllowThreads(__tstate);
32066 if (PyErr_Occurred()) SWIG_fail;
32067 }
32068 {
32069 resultobj = wxPyMake_wxObject(result, 0);
32070 }
32071 return resultobj;
32072 fail:
32073 return NULL;
32074 }
32075
32076
32077 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32078 PyObject *resultobj;
32079 wxWindow *arg1 = (wxWindow *) 0 ;
32080 PyObject * obj0 = 0 ;
32081 char *kwnames[] = {
32082 (char *) "self", NULL
32083 };
32084
32085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32087 if (SWIG_arg_fail(1)) SWIG_fail;
32088 {
32089 PyThreadState* __tstate = wxPyBeginAllowThreads();
32090 (arg1)->InheritAttributes();
32091
32092 wxPyEndAllowThreads(__tstate);
32093 if (PyErr_Occurred()) SWIG_fail;
32094 }
32095 Py_INCREF(Py_None); resultobj = Py_None;
32096 return resultobj;
32097 fail:
32098 return NULL;
32099 }
32100
32101
32102 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32103 PyObject *resultobj;
32104 wxWindow *arg1 = (wxWindow *) 0 ;
32105 bool result;
32106 PyObject * obj0 = 0 ;
32107 char *kwnames[] = {
32108 (char *) "self", NULL
32109 };
32110
32111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32113 if (SWIG_arg_fail(1)) SWIG_fail;
32114 {
32115 PyThreadState* __tstate = wxPyBeginAllowThreads();
32116 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32117
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 {
32122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32123 }
32124 return resultobj;
32125 fail:
32126 return NULL;
32127 }
32128
32129
32130 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32131 PyObject *obj;
32132 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32133 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32134 Py_INCREF(obj);
32135 return Py_BuildValue((char *)"");
32136 }
32137 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32138 PyObject *resultobj;
32139 long arg1 ;
32140 wxWindow *arg2 = (wxWindow *) NULL ;
32141 wxWindow *result;
32142 PyObject * obj0 = 0 ;
32143 PyObject * obj1 = 0 ;
32144 char *kwnames[] = {
32145 (char *) "id",(char *) "parent", NULL
32146 };
32147
32148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32149 {
32150 arg1 = (long)(SWIG_As_long(obj0));
32151 if (SWIG_arg_fail(1)) SWIG_fail;
32152 }
32153 if (obj1) {
32154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32155 if (SWIG_arg_fail(2)) SWIG_fail;
32156 }
32157 {
32158 if (!wxPyCheckForApp()) SWIG_fail;
32159 PyThreadState* __tstate = wxPyBeginAllowThreads();
32160 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32161
32162 wxPyEndAllowThreads(__tstate);
32163 if (PyErr_Occurred()) SWIG_fail;
32164 }
32165 {
32166 resultobj = wxPyMake_wxObject(result, 0);
32167 }
32168 return resultobj;
32169 fail:
32170 return NULL;
32171 }
32172
32173
32174 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32175 PyObject *resultobj;
32176 wxString *arg1 = 0 ;
32177 wxWindow *arg2 = (wxWindow *) NULL ;
32178 wxWindow *result;
32179 bool temp1 = false ;
32180 PyObject * obj0 = 0 ;
32181 PyObject * obj1 = 0 ;
32182 char *kwnames[] = {
32183 (char *) "name",(char *) "parent", NULL
32184 };
32185
32186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32187 {
32188 arg1 = wxString_in_helper(obj0);
32189 if (arg1 == NULL) SWIG_fail;
32190 temp1 = true;
32191 }
32192 if (obj1) {
32193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32194 if (SWIG_arg_fail(2)) SWIG_fail;
32195 }
32196 {
32197 if (!wxPyCheckForApp()) SWIG_fail;
32198 PyThreadState* __tstate = wxPyBeginAllowThreads();
32199 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32200
32201 wxPyEndAllowThreads(__tstate);
32202 if (PyErr_Occurred()) SWIG_fail;
32203 }
32204 {
32205 resultobj = wxPyMake_wxObject(result, 0);
32206 }
32207 {
32208 if (temp1)
32209 delete arg1;
32210 }
32211 return resultobj;
32212 fail:
32213 {
32214 if (temp1)
32215 delete arg1;
32216 }
32217 return NULL;
32218 }
32219
32220
32221 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32222 PyObject *resultobj;
32223 wxString *arg1 = 0 ;
32224 wxWindow *arg2 = (wxWindow *) NULL ;
32225 wxWindow *result;
32226 bool temp1 = false ;
32227 PyObject * obj0 = 0 ;
32228 PyObject * obj1 = 0 ;
32229 char *kwnames[] = {
32230 (char *) "label",(char *) "parent", NULL
32231 };
32232
32233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32234 {
32235 arg1 = wxString_in_helper(obj0);
32236 if (arg1 == NULL) SWIG_fail;
32237 temp1 = true;
32238 }
32239 if (obj1) {
32240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32241 if (SWIG_arg_fail(2)) SWIG_fail;
32242 }
32243 {
32244 if (!wxPyCheckForApp()) SWIG_fail;
32245 PyThreadState* __tstate = wxPyBeginAllowThreads();
32246 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32247
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 {
32252 resultobj = wxPyMake_wxObject(result, 0);
32253 }
32254 {
32255 if (temp1)
32256 delete arg1;
32257 }
32258 return resultobj;
32259 fail:
32260 {
32261 if (temp1)
32262 delete arg1;
32263 }
32264 return NULL;
32265 }
32266
32267
32268 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32269 PyObject *resultobj;
32270 wxWindow *arg1 = (wxWindow *) 0 ;
32271 unsigned long arg2 ;
32272 wxWindow *result;
32273 PyObject * obj0 = 0 ;
32274 PyObject * obj1 = 0 ;
32275 char *kwnames[] = {
32276 (char *) "parent",(char *) "_hWnd", NULL
32277 };
32278
32279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32281 if (SWIG_arg_fail(1)) SWIG_fail;
32282 {
32283 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32284 if (SWIG_arg_fail(2)) SWIG_fail;
32285 }
32286 {
32287 PyThreadState* __tstate = wxPyBeginAllowThreads();
32288 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32289
32290 wxPyEndAllowThreads(__tstate);
32291 if (PyErr_Occurred()) SWIG_fail;
32292 }
32293 {
32294 resultobj = wxPyMake_wxObject(result, 0);
32295 }
32296 return resultobj;
32297 fail:
32298 return NULL;
32299 }
32300
32301
32302 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32303 PyObject *resultobj;
32304 PyObject *result;
32305 char *kwnames[] = {
32306 NULL
32307 };
32308
32309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32310 {
32311 PyThreadState* __tstate = wxPyBeginAllowThreads();
32312 result = (PyObject *)GetTopLevelWindows();
32313
32314 wxPyEndAllowThreads(__tstate);
32315 if (PyErr_Occurred()) SWIG_fail;
32316 }
32317 resultobj = result;
32318 return resultobj;
32319 fail:
32320 return NULL;
32321 }
32322
32323
32324 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32325 PyObject *resultobj;
32326 wxValidator *result;
32327 char *kwnames[] = {
32328 NULL
32329 };
32330
32331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32332 {
32333 PyThreadState* __tstate = wxPyBeginAllowThreads();
32334 result = (wxValidator *)new wxValidator();
32335
32336 wxPyEndAllowThreads(__tstate);
32337 if (PyErr_Occurred()) SWIG_fail;
32338 }
32339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32340 return resultobj;
32341 fail:
32342 return NULL;
32343 }
32344
32345
32346 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32347 PyObject *resultobj;
32348 wxValidator *arg1 = (wxValidator *) 0 ;
32349 wxValidator *result;
32350 PyObject * obj0 = 0 ;
32351 char *kwnames[] = {
32352 (char *) "self", NULL
32353 };
32354
32355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32357 if (SWIG_arg_fail(1)) SWIG_fail;
32358 {
32359 PyThreadState* __tstate = wxPyBeginAllowThreads();
32360 result = (wxValidator *)(arg1)->Clone();
32361
32362 wxPyEndAllowThreads(__tstate);
32363 if (PyErr_Occurred()) SWIG_fail;
32364 }
32365 {
32366 resultobj = wxPyMake_wxObject(result, 0);
32367 }
32368 return resultobj;
32369 fail:
32370 return NULL;
32371 }
32372
32373
32374 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32375 PyObject *resultobj;
32376 wxValidator *arg1 = (wxValidator *) 0 ;
32377 wxWindow *arg2 = (wxWindow *) 0 ;
32378 bool result;
32379 PyObject * obj0 = 0 ;
32380 PyObject * obj1 = 0 ;
32381 char *kwnames[] = {
32382 (char *) "self",(char *) "parent", NULL
32383 };
32384
32385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32387 if (SWIG_arg_fail(1)) SWIG_fail;
32388 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32389 if (SWIG_arg_fail(2)) SWIG_fail;
32390 {
32391 PyThreadState* __tstate = wxPyBeginAllowThreads();
32392 result = (bool)(arg1)->Validate(arg2);
32393
32394 wxPyEndAllowThreads(__tstate);
32395 if (PyErr_Occurred()) SWIG_fail;
32396 }
32397 {
32398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32399 }
32400 return resultobj;
32401 fail:
32402 return NULL;
32403 }
32404
32405
32406 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32407 PyObject *resultobj;
32408 wxValidator *arg1 = (wxValidator *) 0 ;
32409 bool result;
32410 PyObject * obj0 = 0 ;
32411 char *kwnames[] = {
32412 (char *) "self", NULL
32413 };
32414
32415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32417 if (SWIG_arg_fail(1)) SWIG_fail;
32418 {
32419 PyThreadState* __tstate = wxPyBeginAllowThreads();
32420 result = (bool)(arg1)->TransferToWindow();
32421
32422 wxPyEndAllowThreads(__tstate);
32423 if (PyErr_Occurred()) SWIG_fail;
32424 }
32425 {
32426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32427 }
32428 return resultobj;
32429 fail:
32430 return NULL;
32431 }
32432
32433
32434 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32435 PyObject *resultobj;
32436 wxValidator *arg1 = (wxValidator *) 0 ;
32437 bool result;
32438 PyObject * obj0 = 0 ;
32439 char *kwnames[] = {
32440 (char *) "self", NULL
32441 };
32442
32443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32445 if (SWIG_arg_fail(1)) SWIG_fail;
32446 {
32447 PyThreadState* __tstate = wxPyBeginAllowThreads();
32448 result = (bool)(arg1)->TransferFromWindow();
32449
32450 wxPyEndAllowThreads(__tstate);
32451 if (PyErr_Occurred()) SWIG_fail;
32452 }
32453 {
32454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32455 }
32456 return resultobj;
32457 fail:
32458 return NULL;
32459 }
32460
32461
32462 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32463 PyObject *resultobj;
32464 wxValidator *arg1 = (wxValidator *) 0 ;
32465 wxWindow *result;
32466 PyObject * obj0 = 0 ;
32467 char *kwnames[] = {
32468 (char *) "self", NULL
32469 };
32470
32471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32473 if (SWIG_arg_fail(1)) SWIG_fail;
32474 {
32475 PyThreadState* __tstate = wxPyBeginAllowThreads();
32476 result = (wxWindow *)(arg1)->GetWindow();
32477
32478 wxPyEndAllowThreads(__tstate);
32479 if (PyErr_Occurred()) SWIG_fail;
32480 }
32481 {
32482 resultobj = wxPyMake_wxObject(result, 0);
32483 }
32484 return resultobj;
32485 fail:
32486 return NULL;
32487 }
32488
32489
32490 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32491 PyObject *resultobj;
32492 wxValidator *arg1 = (wxValidator *) 0 ;
32493 wxWindow *arg2 = (wxWindow *) 0 ;
32494 PyObject * obj0 = 0 ;
32495 PyObject * obj1 = 0 ;
32496 char *kwnames[] = {
32497 (char *) "self",(char *) "window", NULL
32498 };
32499
32500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32502 if (SWIG_arg_fail(1)) SWIG_fail;
32503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32504 if (SWIG_arg_fail(2)) SWIG_fail;
32505 {
32506 PyThreadState* __tstate = wxPyBeginAllowThreads();
32507 (arg1)->SetWindow(arg2);
32508
32509 wxPyEndAllowThreads(__tstate);
32510 if (PyErr_Occurred()) SWIG_fail;
32511 }
32512 Py_INCREF(Py_None); resultobj = Py_None;
32513 return resultobj;
32514 fail:
32515 return NULL;
32516 }
32517
32518
32519 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32520 PyObject *resultobj;
32521 bool result;
32522 char *kwnames[] = {
32523 NULL
32524 };
32525
32526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32527 {
32528 PyThreadState* __tstate = wxPyBeginAllowThreads();
32529 result = (bool)wxValidator::IsSilent();
32530
32531 wxPyEndAllowThreads(__tstate);
32532 if (PyErr_Occurred()) SWIG_fail;
32533 }
32534 {
32535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32536 }
32537 return resultobj;
32538 fail:
32539 return NULL;
32540 }
32541
32542
32543 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32544 PyObject *resultobj;
32545 int arg1 = (int) true ;
32546 PyObject * obj0 = 0 ;
32547 char *kwnames[] = {
32548 (char *) "doIt", NULL
32549 };
32550
32551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32552 if (obj0) {
32553 {
32554 arg1 = (int)(SWIG_As_int(obj0));
32555 if (SWIG_arg_fail(1)) SWIG_fail;
32556 }
32557 }
32558 {
32559 PyThreadState* __tstate = wxPyBeginAllowThreads();
32560 wxValidator::SetBellOnError(arg1);
32561
32562 wxPyEndAllowThreads(__tstate);
32563 if (PyErr_Occurred()) SWIG_fail;
32564 }
32565 Py_INCREF(Py_None); resultobj = Py_None;
32566 return resultobj;
32567 fail:
32568 return NULL;
32569 }
32570
32571
32572 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32573 PyObject *obj;
32574 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32575 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32576 Py_INCREF(obj);
32577 return Py_BuildValue((char *)"");
32578 }
32579 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32580 PyObject *resultobj;
32581 wxPyValidator *result;
32582 char *kwnames[] = {
32583 NULL
32584 };
32585
32586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32587 {
32588 PyThreadState* __tstate = wxPyBeginAllowThreads();
32589 result = (wxPyValidator *)new wxPyValidator();
32590
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32595 return resultobj;
32596 fail:
32597 return NULL;
32598 }
32599
32600
32601 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32602 PyObject *resultobj;
32603 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32604 PyObject *arg2 = (PyObject *) 0 ;
32605 PyObject *arg3 = (PyObject *) 0 ;
32606 int arg4 = (int) true ;
32607 PyObject * obj0 = 0 ;
32608 PyObject * obj1 = 0 ;
32609 PyObject * obj2 = 0 ;
32610 PyObject * obj3 = 0 ;
32611 char *kwnames[] = {
32612 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32613 };
32614
32615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32617 if (SWIG_arg_fail(1)) SWIG_fail;
32618 arg2 = obj1;
32619 arg3 = obj2;
32620 if (obj3) {
32621 {
32622 arg4 = (int)(SWIG_As_int(obj3));
32623 if (SWIG_arg_fail(4)) SWIG_fail;
32624 }
32625 }
32626 {
32627 PyThreadState* __tstate = wxPyBeginAllowThreads();
32628 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32629
32630 wxPyEndAllowThreads(__tstate);
32631 if (PyErr_Occurred()) SWIG_fail;
32632 }
32633 Py_INCREF(Py_None); resultobj = Py_None;
32634 return resultobj;
32635 fail:
32636 return NULL;
32637 }
32638
32639
32640 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32641 PyObject *obj;
32642 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32643 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32644 Py_INCREF(obj);
32645 return Py_BuildValue((char *)"");
32646 }
32647 static int _wrap_DefaultValidator_set(PyObject *) {
32648 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32649 return 1;
32650 }
32651
32652
32653 static PyObject *_wrap_DefaultValidator_get(void) {
32654 PyObject *pyobj;
32655
32656 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32657 return pyobj;
32658 }
32659
32660
32661 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32662 PyObject *resultobj;
32663 wxString const &arg1_defvalue = wxPyEmptyString ;
32664 wxString *arg1 = (wxString *) &arg1_defvalue ;
32665 long arg2 = (long) 0 ;
32666 wxMenu *result;
32667 bool temp1 = false ;
32668 PyObject * obj0 = 0 ;
32669 PyObject * obj1 = 0 ;
32670 char *kwnames[] = {
32671 (char *) "title",(char *) "style", NULL
32672 };
32673
32674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32675 if (obj0) {
32676 {
32677 arg1 = wxString_in_helper(obj0);
32678 if (arg1 == NULL) SWIG_fail;
32679 temp1 = true;
32680 }
32681 }
32682 if (obj1) {
32683 {
32684 arg2 = (long)(SWIG_As_long(obj1));
32685 if (SWIG_arg_fail(2)) SWIG_fail;
32686 }
32687 }
32688 {
32689 if (!wxPyCheckForApp()) SWIG_fail;
32690 PyThreadState* __tstate = wxPyBeginAllowThreads();
32691 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32692
32693 wxPyEndAllowThreads(__tstate);
32694 if (PyErr_Occurred()) SWIG_fail;
32695 }
32696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32697 {
32698 if (temp1)
32699 delete arg1;
32700 }
32701 return resultobj;
32702 fail:
32703 {
32704 if (temp1)
32705 delete arg1;
32706 }
32707 return NULL;
32708 }
32709
32710
32711 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32712 PyObject *resultobj;
32713 wxMenu *arg1 = (wxMenu *) 0 ;
32714 int arg2 ;
32715 wxString *arg3 = 0 ;
32716 wxString const &arg4_defvalue = wxPyEmptyString ;
32717 wxString *arg4 = (wxString *) &arg4_defvalue ;
32718 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32719 wxMenuItem *result;
32720 bool temp3 = false ;
32721 bool temp4 = false ;
32722 PyObject * obj0 = 0 ;
32723 PyObject * obj1 = 0 ;
32724 PyObject * obj2 = 0 ;
32725 PyObject * obj3 = 0 ;
32726 PyObject * obj4 = 0 ;
32727 char *kwnames[] = {
32728 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32729 };
32730
32731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32733 if (SWIG_arg_fail(1)) SWIG_fail;
32734 {
32735 arg2 = (int)(SWIG_As_int(obj1));
32736 if (SWIG_arg_fail(2)) SWIG_fail;
32737 }
32738 {
32739 arg3 = wxString_in_helper(obj2);
32740 if (arg3 == NULL) SWIG_fail;
32741 temp3 = true;
32742 }
32743 if (obj3) {
32744 {
32745 arg4 = wxString_in_helper(obj3);
32746 if (arg4 == NULL) SWIG_fail;
32747 temp4 = true;
32748 }
32749 }
32750 if (obj4) {
32751 {
32752 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32753 if (SWIG_arg_fail(5)) SWIG_fail;
32754 }
32755 }
32756 {
32757 PyThreadState* __tstate = wxPyBeginAllowThreads();
32758 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32759
32760 wxPyEndAllowThreads(__tstate);
32761 if (PyErr_Occurred()) SWIG_fail;
32762 }
32763 {
32764 resultobj = wxPyMake_wxObject(result, 0);
32765 }
32766 {
32767 if (temp3)
32768 delete arg3;
32769 }
32770 {
32771 if (temp4)
32772 delete arg4;
32773 }
32774 return resultobj;
32775 fail:
32776 {
32777 if (temp3)
32778 delete arg3;
32779 }
32780 {
32781 if (temp4)
32782 delete arg4;
32783 }
32784 return NULL;
32785 }
32786
32787
32788 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32789 PyObject *resultobj;
32790 wxMenu *arg1 = (wxMenu *) 0 ;
32791 wxMenuItem *result;
32792 PyObject * obj0 = 0 ;
32793 char *kwnames[] = {
32794 (char *) "self", NULL
32795 };
32796
32797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32799 if (SWIG_arg_fail(1)) SWIG_fail;
32800 {
32801 PyThreadState* __tstate = wxPyBeginAllowThreads();
32802 result = (wxMenuItem *)(arg1)->AppendSeparator();
32803
32804 wxPyEndAllowThreads(__tstate);
32805 if (PyErr_Occurred()) SWIG_fail;
32806 }
32807 {
32808 resultobj = wxPyMake_wxObject(result, 0);
32809 }
32810 return resultobj;
32811 fail:
32812 return NULL;
32813 }
32814
32815
32816 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32817 PyObject *resultobj;
32818 wxMenu *arg1 = (wxMenu *) 0 ;
32819 int arg2 ;
32820 wxString *arg3 = 0 ;
32821 wxString const &arg4_defvalue = wxPyEmptyString ;
32822 wxString *arg4 = (wxString *) &arg4_defvalue ;
32823 wxMenuItem *result;
32824 bool temp3 = false ;
32825 bool temp4 = false ;
32826 PyObject * obj0 = 0 ;
32827 PyObject * obj1 = 0 ;
32828 PyObject * obj2 = 0 ;
32829 PyObject * obj3 = 0 ;
32830 char *kwnames[] = {
32831 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32832 };
32833
32834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32836 if (SWIG_arg_fail(1)) SWIG_fail;
32837 {
32838 arg2 = (int)(SWIG_As_int(obj1));
32839 if (SWIG_arg_fail(2)) SWIG_fail;
32840 }
32841 {
32842 arg3 = wxString_in_helper(obj2);
32843 if (arg3 == NULL) SWIG_fail;
32844 temp3 = true;
32845 }
32846 if (obj3) {
32847 {
32848 arg4 = wxString_in_helper(obj3);
32849 if (arg4 == NULL) SWIG_fail;
32850 temp4 = true;
32851 }
32852 }
32853 {
32854 PyThreadState* __tstate = wxPyBeginAllowThreads();
32855 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32856
32857 wxPyEndAllowThreads(__tstate);
32858 if (PyErr_Occurred()) SWIG_fail;
32859 }
32860 {
32861 resultobj = wxPyMake_wxObject(result, 0);
32862 }
32863 {
32864 if (temp3)
32865 delete arg3;
32866 }
32867 {
32868 if (temp4)
32869 delete arg4;
32870 }
32871 return resultobj;
32872 fail:
32873 {
32874 if (temp3)
32875 delete arg3;
32876 }
32877 {
32878 if (temp4)
32879 delete arg4;
32880 }
32881 return NULL;
32882 }
32883
32884
32885 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32886 PyObject *resultobj;
32887 wxMenu *arg1 = (wxMenu *) 0 ;
32888 int arg2 ;
32889 wxString *arg3 = 0 ;
32890 wxString const &arg4_defvalue = wxPyEmptyString ;
32891 wxString *arg4 = (wxString *) &arg4_defvalue ;
32892 wxMenuItem *result;
32893 bool temp3 = false ;
32894 bool temp4 = false ;
32895 PyObject * obj0 = 0 ;
32896 PyObject * obj1 = 0 ;
32897 PyObject * obj2 = 0 ;
32898 PyObject * obj3 = 0 ;
32899 char *kwnames[] = {
32900 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32901 };
32902
32903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32905 if (SWIG_arg_fail(1)) SWIG_fail;
32906 {
32907 arg2 = (int)(SWIG_As_int(obj1));
32908 if (SWIG_arg_fail(2)) SWIG_fail;
32909 }
32910 {
32911 arg3 = wxString_in_helper(obj2);
32912 if (arg3 == NULL) SWIG_fail;
32913 temp3 = true;
32914 }
32915 if (obj3) {
32916 {
32917 arg4 = wxString_in_helper(obj3);
32918 if (arg4 == NULL) SWIG_fail;
32919 temp4 = true;
32920 }
32921 }
32922 {
32923 PyThreadState* __tstate = wxPyBeginAllowThreads();
32924 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32925
32926 wxPyEndAllowThreads(__tstate);
32927 if (PyErr_Occurred()) SWIG_fail;
32928 }
32929 {
32930 resultobj = wxPyMake_wxObject(result, 0);
32931 }
32932 {
32933 if (temp3)
32934 delete arg3;
32935 }
32936 {
32937 if (temp4)
32938 delete arg4;
32939 }
32940 return resultobj;
32941 fail:
32942 {
32943 if (temp3)
32944 delete arg3;
32945 }
32946 {
32947 if (temp4)
32948 delete arg4;
32949 }
32950 return NULL;
32951 }
32952
32953
32954 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32955 PyObject *resultobj;
32956 wxMenu *arg1 = (wxMenu *) 0 ;
32957 int arg2 ;
32958 wxString *arg3 = 0 ;
32959 wxMenu *arg4 = (wxMenu *) 0 ;
32960 wxString const &arg5_defvalue = wxPyEmptyString ;
32961 wxString *arg5 = (wxString *) &arg5_defvalue ;
32962 wxMenuItem *result;
32963 bool temp3 = false ;
32964 bool temp5 = false ;
32965 PyObject * obj0 = 0 ;
32966 PyObject * obj1 = 0 ;
32967 PyObject * obj2 = 0 ;
32968 PyObject * obj3 = 0 ;
32969 PyObject * obj4 = 0 ;
32970 char *kwnames[] = {
32971 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32972 };
32973
32974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32976 if (SWIG_arg_fail(1)) SWIG_fail;
32977 {
32978 arg2 = (int)(SWIG_As_int(obj1));
32979 if (SWIG_arg_fail(2)) SWIG_fail;
32980 }
32981 {
32982 arg3 = wxString_in_helper(obj2);
32983 if (arg3 == NULL) SWIG_fail;
32984 temp3 = true;
32985 }
32986 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32987 if (SWIG_arg_fail(4)) SWIG_fail;
32988 if (obj4) {
32989 {
32990 arg5 = wxString_in_helper(obj4);
32991 if (arg5 == NULL) SWIG_fail;
32992 temp5 = true;
32993 }
32994 }
32995 {
32996 PyThreadState* __tstate = wxPyBeginAllowThreads();
32997 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32998
32999 wxPyEndAllowThreads(__tstate);
33000 if (PyErr_Occurred()) SWIG_fail;
33001 }
33002 {
33003 resultobj = wxPyMake_wxObject(result, 0);
33004 }
33005 {
33006 if (temp3)
33007 delete arg3;
33008 }
33009 {
33010 if (temp5)
33011 delete arg5;
33012 }
33013 return resultobj;
33014 fail:
33015 {
33016 if (temp3)
33017 delete arg3;
33018 }
33019 {
33020 if (temp5)
33021 delete arg5;
33022 }
33023 return NULL;
33024 }
33025
33026
33027 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33028 PyObject *resultobj;
33029 wxMenu *arg1 = (wxMenu *) 0 ;
33030 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33031 wxMenuItem *result;
33032 PyObject * obj0 = 0 ;
33033 PyObject * obj1 = 0 ;
33034 char *kwnames[] = {
33035 (char *) "self",(char *) "item", NULL
33036 };
33037
33038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33040 if (SWIG_arg_fail(1)) SWIG_fail;
33041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33042 if (SWIG_arg_fail(2)) SWIG_fail;
33043 {
33044 PyThreadState* __tstate = wxPyBeginAllowThreads();
33045 result = (wxMenuItem *)(arg1)->Append(arg2);
33046
33047 wxPyEndAllowThreads(__tstate);
33048 if (PyErr_Occurred()) SWIG_fail;
33049 }
33050 {
33051 resultobj = wxPyMake_wxObject(result, 0);
33052 }
33053 return resultobj;
33054 fail:
33055 return NULL;
33056 }
33057
33058
33059 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33060 PyObject *resultobj;
33061 wxMenu *arg1 = (wxMenu *) 0 ;
33062 PyObject * obj0 = 0 ;
33063 char *kwnames[] = {
33064 (char *) "self", NULL
33065 };
33066
33067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33069 if (SWIG_arg_fail(1)) SWIG_fail;
33070 {
33071 PyThreadState* __tstate = wxPyBeginAllowThreads();
33072 (arg1)->Break();
33073
33074 wxPyEndAllowThreads(__tstate);
33075 if (PyErr_Occurred()) SWIG_fail;
33076 }
33077 Py_INCREF(Py_None); resultobj = Py_None;
33078 return resultobj;
33079 fail:
33080 return NULL;
33081 }
33082
33083
33084 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33085 PyObject *resultobj;
33086 wxMenu *arg1 = (wxMenu *) 0 ;
33087 size_t arg2 ;
33088 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33089 wxMenuItem *result;
33090 PyObject * obj0 = 0 ;
33091 PyObject * obj1 = 0 ;
33092 PyObject * obj2 = 0 ;
33093 char *kwnames[] = {
33094 (char *) "self",(char *) "pos",(char *) "item", NULL
33095 };
33096
33097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33099 if (SWIG_arg_fail(1)) SWIG_fail;
33100 {
33101 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33102 if (SWIG_arg_fail(2)) SWIG_fail;
33103 }
33104 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33105 if (SWIG_arg_fail(3)) SWIG_fail;
33106 {
33107 PyThreadState* __tstate = wxPyBeginAllowThreads();
33108 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33109
33110 wxPyEndAllowThreads(__tstate);
33111 if (PyErr_Occurred()) SWIG_fail;
33112 }
33113 {
33114 resultobj = wxPyMake_wxObject(result, 0);
33115 }
33116 return resultobj;
33117 fail:
33118 return NULL;
33119 }
33120
33121
33122 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33123 PyObject *resultobj;
33124 wxMenu *arg1 = (wxMenu *) 0 ;
33125 size_t arg2 ;
33126 int arg3 ;
33127 wxString *arg4 = 0 ;
33128 wxString const &arg5_defvalue = wxPyEmptyString ;
33129 wxString *arg5 = (wxString *) &arg5_defvalue ;
33130 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33131 wxMenuItem *result;
33132 bool temp4 = false ;
33133 bool temp5 = false ;
33134 PyObject * obj0 = 0 ;
33135 PyObject * obj1 = 0 ;
33136 PyObject * obj2 = 0 ;
33137 PyObject * obj3 = 0 ;
33138 PyObject * obj4 = 0 ;
33139 PyObject * obj5 = 0 ;
33140 char *kwnames[] = {
33141 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33142 };
33143
33144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33146 if (SWIG_arg_fail(1)) SWIG_fail;
33147 {
33148 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33149 if (SWIG_arg_fail(2)) SWIG_fail;
33150 }
33151 {
33152 arg3 = (int)(SWIG_As_int(obj2));
33153 if (SWIG_arg_fail(3)) SWIG_fail;
33154 }
33155 {
33156 arg4 = wxString_in_helper(obj3);
33157 if (arg4 == NULL) SWIG_fail;
33158 temp4 = true;
33159 }
33160 if (obj4) {
33161 {
33162 arg5 = wxString_in_helper(obj4);
33163 if (arg5 == NULL) SWIG_fail;
33164 temp5 = true;
33165 }
33166 }
33167 if (obj5) {
33168 {
33169 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33170 if (SWIG_arg_fail(6)) SWIG_fail;
33171 }
33172 }
33173 {
33174 PyThreadState* __tstate = wxPyBeginAllowThreads();
33175 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33176
33177 wxPyEndAllowThreads(__tstate);
33178 if (PyErr_Occurred()) SWIG_fail;
33179 }
33180 {
33181 resultobj = wxPyMake_wxObject(result, 0);
33182 }
33183 {
33184 if (temp4)
33185 delete arg4;
33186 }
33187 {
33188 if (temp5)
33189 delete arg5;
33190 }
33191 return resultobj;
33192 fail:
33193 {
33194 if (temp4)
33195 delete arg4;
33196 }
33197 {
33198 if (temp5)
33199 delete arg5;
33200 }
33201 return NULL;
33202 }
33203
33204
33205 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33206 PyObject *resultobj;
33207 wxMenu *arg1 = (wxMenu *) 0 ;
33208 size_t arg2 ;
33209 wxMenuItem *result;
33210 PyObject * obj0 = 0 ;
33211 PyObject * obj1 = 0 ;
33212 char *kwnames[] = {
33213 (char *) "self",(char *) "pos", NULL
33214 };
33215
33216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33218 if (SWIG_arg_fail(1)) SWIG_fail;
33219 {
33220 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33221 if (SWIG_arg_fail(2)) SWIG_fail;
33222 }
33223 {
33224 PyThreadState* __tstate = wxPyBeginAllowThreads();
33225 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33226
33227 wxPyEndAllowThreads(__tstate);
33228 if (PyErr_Occurred()) SWIG_fail;
33229 }
33230 {
33231 resultobj = wxPyMake_wxObject(result, 0);
33232 }
33233 return resultobj;
33234 fail:
33235 return NULL;
33236 }
33237
33238
33239 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33240 PyObject *resultobj;
33241 wxMenu *arg1 = (wxMenu *) 0 ;
33242 size_t arg2 ;
33243 int arg3 ;
33244 wxString *arg4 = 0 ;
33245 wxString const &arg5_defvalue = wxPyEmptyString ;
33246 wxString *arg5 = (wxString *) &arg5_defvalue ;
33247 wxMenuItem *result;
33248 bool temp4 = false ;
33249 bool temp5 = false ;
33250 PyObject * obj0 = 0 ;
33251 PyObject * obj1 = 0 ;
33252 PyObject * obj2 = 0 ;
33253 PyObject * obj3 = 0 ;
33254 PyObject * obj4 = 0 ;
33255 char *kwnames[] = {
33256 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33257 };
33258
33259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33261 if (SWIG_arg_fail(1)) SWIG_fail;
33262 {
33263 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33264 if (SWIG_arg_fail(2)) SWIG_fail;
33265 }
33266 {
33267 arg3 = (int)(SWIG_As_int(obj2));
33268 if (SWIG_arg_fail(3)) SWIG_fail;
33269 }
33270 {
33271 arg4 = wxString_in_helper(obj3);
33272 if (arg4 == NULL) SWIG_fail;
33273 temp4 = true;
33274 }
33275 if (obj4) {
33276 {
33277 arg5 = wxString_in_helper(obj4);
33278 if (arg5 == NULL) SWIG_fail;
33279 temp5 = true;
33280 }
33281 }
33282 {
33283 PyThreadState* __tstate = wxPyBeginAllowThreads();
33284 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33285
33286 wxPyEndAllowThreads(__tstate);
33287 if (PyErr_Occurred()) SWIG_fail;
33288 }
33289 {
33290 resultobj = wxPyMake_wxObject(result, 0);
33291 }
33292 {
33293 if (temp4)
33294 delete arg4;
33295 }
33296 {
33297 if (temp5)
33298 delete arg5;
33299 }
33300 return resultobj;
33301 fail:
33302 {
33303 if (temp4)
33304 delete arg4;
33305 }
33306 {
33307 if (temp5)
33308 delete arg5;
33309 }
33310 return NULL;
33311 }
33312
33313
33314 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33315 PyObject *resultobj;
33316 wxMenu *arg1 = (wxMenu *) 0 ;
33317 size_t arg2 ;
33318 int arg3 ;
33319 wxString *arg4 = 0 ;
33320 wxString const &arg5_defvalue = wxPyEmptyString ;
33321 wxString *arg5 = (wxString *) &arg5_defvalue ;
33322 wxMenuItem *result;
33323 bool temp4 = false ;
33324 bool temp5 = false ;
33325 PyObject * obj0 = 0 ;
33326 PyObject * obj1 = 0 ;
33327 PyObject * obj2 = 0 ;
33328 PyObject * obj3 = 0 ;
33329 PyObject * obj4 = 0 ;
33330 char *kwnames[] = {
33331 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33332 };
33333
33334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33336 if (SWIG_arg_fail(1)) SWIG_fail;
33337 {
33338 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33339 if (SWIG_arg_fail(2)) SWIG_fail;
33340 }
33341 {
33342 arg3 = (int)(SWIG_As_int(obj2));
33343 if (SWIG_arg_fail(3)) SWIG_fail;
33344 }
33345 {
33346 arg4 = wxString_in_helper(obj3);
33347 if (arg4 == NULL) SWIG_fail;
33348 temp4 = true;
33349 }
33350 if (obj4) {
33351 {
33352 arg5 = wxString_in_helper(obj4);
33353 if (arg5 == NULL) SWIG_fail;
33354 temp5 = true;
33355 }
33356 }
33357 {
33358 PyThreadState* __tstate = wxPyBeginAllowThreads();
33359 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33360
33361 wxPyEndAllowThreads(__tstate);
33362 if (PyErr_Occurred()) SWIG_fail;
33363 }
33364 {
33365 resultobj = wxPyMake_wxObject(result, 0);
33366 }
33367 {
33368 if (temp4)
33369 delete arg4;
33370 }
33371 {
33372 if (temp5)
33373 delete arg5;
33374 }
33375 return resultobj;
33376 fail:
33377 {
33378 if (temp4)
33379 delete arg4;
33380 }
33381 {
33382 if (temp5)
33383 delete arg5;
33384 }
33385 return NULL;
33386 }
33387
33388
33389 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33390 PyObject *resultobj;
33391 wxMenu *arg1 = (wxMenu *) 0 ;
33392 size_t arg2 ;
33393 int arg3 ;
33394 wxString *arg4 = 0 ;
33395 wxMenu *arg5 = (wxMenu *) 0 ;
33396 wxString const &arg6_defvalue = wxPyEmptyString ;
33397 wxString *arg6 = (wxString *) &arg6_defvalue ;
33398 wxMenuItem *result;
33399 bool temp4 = false ;
33400 bool temp6 = false ;
33401 PyObject * obj0 = 0 ;
33402 PyObject * obj1 = 0 ;
33403 PyObject * obj2 = 0 ;
33404 PyObject * obj3 = 0 ;
33405 PyObject * obj4 = 0 ;
33406 PyObject * obj5 = 0 ;
33407 char *kwnames[] = {
33408 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33409 };
33410
33411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33413 if (SWIG_arg_fail(1)) SWIG_fail;
33414 {
33415 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33416 if (SWIG_arg_fail(2)) SWIG_fail;
33417 }
33418 {
33419 arg3 = (int)(SWIG_As_int(obj2));
33420 if (SWIG_arg_fail(3)) SWIG_fail;
33421 }
33422 {
33423 arg4 = wxString_in_helper(obj3);
33424 if (arg4 == NULL) SWIG_fail;
33425 temp4 = true;
33426 }
33427 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33428 if (SWIG_arg_fail(5)) SWIG_fail;
33429 if (obj5) {
33430 {
33431 arg6 = wxString_in_helper(obj5);
33432 if (arg6 == NULL) SWIG_fail;
33433 temp6 = true;
33434 }
33435 }
33436 {
33437 PyThreadState* __tstate = wxPyBeginAllowThreads();
33438 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33439
33440 wxPyEndAllowThreads(__tstate);
33441 if (PyErr_Occurred()) SWIG_fail;
33442 }
33443 {
33444 resultobj = wxPyMake_wxObject(result, 0);
33445 }
33446 {
33447 if (temp4)
33448 delete arg4;
33449 }
33450 {
33451 if (temp6)
33452 delete arg6;
33453 }
33454 return resultobj;
33455 fail:
33456 {
33457 if (temp4)
33458 delete arg4;
33459 }
33460 {
33461 if (temp6)
33462 delete arg6;
33463 }
33464 return NULL;
33465 }
33466
33467
33468 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33469 PyObject *resultobj;
33470 wxMenu *arg1 = (wxMenu *) 0 ;
33471 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33472 wxMenuItem *result;
33473 PyObject * obj0 = 0 ;
33474 PyObject * obj1 = 0 ;
33475 char *kwnames[] = {
33476 (char *) "self",(char *) "item", NULL
33477 };
33478
33479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33481 if (SWIG_arg_fail(1)) SWIG_fail;
33482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33483 if (SWIG_arg_fail(2)) SWIG_fail;
33484 {
33485 PyThreadState* __tstate = wxPyBeginAllowThreads();
33486 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33487
33488 wxPyEndAllowThreads(__tstate);
33489 if (PyErr_Occurred()) SWIG_fail;
33490 }
33491 {
33492 resultobj = wxPyMake_wxObject(result, 0);
33493 }
33494 return resultobj;
33495 fail:
33496 return NULL;
33497 }
33498
33499
33500 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33501 PyObject *resultobj;
33502 wxMenu *arg1 = (wxMenu *) 0 ;
33503 int arg2 ;
33504 wxString *arg3 = 0 ;
33505 wxString const &arg4_defvalue = wxPyEmptyString ;
33506 wxString *arg4 = (wxString *) &arg4_defvalue ;
33507 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33508 wxMenuItem *result;
33509 bool temp3 = false ;
33510 bool temp4 = false ;
33511 PyObject * obj0 = 0 ;
33512 PyObject * obj1 = 0 ;
33513 PyObject * obj2 = 0 ;
33514 PyObject * obj3 = 0 ;
33515 PyObject * obj4 = 0 ;
33516 char *kwnames[] = {
33517 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33518 };
33519
33520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33522 if (SWIG_arg_fail(1)) SWIG_fail;
33523 {
33524 arg2 = (int)(SWIG_As_int(obj1));
33525 if (SWIG_arg_fail(2)) SWIG_fail;
33526 }
33527 {
33528 arg3 = wxString_in_helper(obj2);
33529 if (arg3 == NULL) SWIG_fail;
33530 temp3 = true;
33531 }
33532 if (obj3) {
33533 {
33534 arg4 = wxString_in_helper(obj3);
33535 if (arg4 == NULL) SWIG_fail;
33536 temp4 = true;
33537 }
33538 }
33539 if (obj4) {
33540 {
33541 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33542 if (SWIG_arg_fail(5)) SWIG_fail;
33543 }
33544 }
33545 {
33546 PyThreadState* __tstate = wxPyBeginAllowThreads();
33547 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33548
33549 wxPyEndAllowThreads(__tstate);
33550 if (PyErr_Occurred()) SWIG_fail;
33551 }
33552 {
33553 resultobj = wxPyMake_wxObject(result, 0);
33554 }
33555 {
33556 if (temp3)
33557 delete arg3;
33558 }
33559 {
33560 if (temp4)
33561 delete arg4;
33562 }
33563 return resultobj;
33564 fail:
33565 {
33566 if (temp3)
33567 delete arg3;
33568 }
33569 {
33570 if (temp4)
33571 delete arg4;
33572 }
33573 return NULL;
33574 }
33575
33576
33577 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33578 PyObject *resultobj;
33579 wxMenu *arg1 = (wxMenu *) 0 ;
33580 wxMenuItem *result;
33581 PyObject * obj0 = 0 ;
33582 char *kwnames[] = {
33583 (char *) "self", NULL
33584 };
33585
33586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33588 if (SWIG_arg_fail(1)) SWIG_fail;
33589 {
33590 PyThreadState* __tstate = wxPyBeginAllowThreads();
33591 result = (wxMenuItem *)(arg1)->PrependSeparator();
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_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33606 PyObject *resultobj;
33607 wxMenu *arg1 = (wxMenu *) 0 ;
33608 int arg2 ;
33609 wxString *arg3 = 0 ;
33610 wxString const &arg4_defvalue = wxPyEmptyString ;
33611 wxString *arg4 = (wxString *) &arg4_defvalue ;
33612 wxMenuItem *result;
33613 bool temp3 = false ;
33614 bool temp4 = false ;
33615 PyObject * obj0 = 0 ;
33616 PyObject * obj1 = 0 ;
33617 PyObject * obj2 = 0 ;
33618 PyObject * obj3 = 0 ;
33619 char *kwnames[] = {
33620 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33621 };
33622
33623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33625 if (SWIG_arg_fail(1)) SWIG_fail;
33626 {
33627 arg2 = (int)(SWIG_As_int(obj1));
33628 if (SWIG_arg_fail(2)) SWIG_fail;
33629 }
33630 {
33631 arg3 = wxString_in_helper(obj2);
33632 if (arg3 == NULL) SWIG_fail;
33633 temp3 = true;
33634 }
33635 if (obj3) {
33636 {
33637 arg4 = wxString_in_helper(obj3);
33638 if (arg4 == NULL) SWIG_fail;
33639 temp4 = true;
33640 }
33641 }
33642 {
33643 PyThreadState* __tstate = wxPyBeginAllowThreads();
33644 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33645
33646 wxPyEndAllowThreads(__tstate);
33647 if (PyErr_Occurred()) SWIG_fail;
33648 }
33649 {
33650 resultobj = wxPyMake_wxObject(result, 0);
33651 }
33652 {
33653 if (temp3)
33654 delete arg3;
33655 }
33656 {
33657 if (temp4)
33658 delete arg4;
33659 }
33660 return resultobj;
33661 fail:
33662 {
33663 if (temp3)
33664 delete arg3;
33665 }
33666 {
33667 if (temp4)
33668 delete arg4;
33669 }
33670 return NULL;
33671 }
33672
33673
33674 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33675 PyObject *resultobj;
33676 wxMenu *arg1 = (wxMenu *) 0 ;
33677 int arg2 ;
33678 wxString *arg3 = 0 ;
33679 wxString const &arg4_defvalue = wxPyEmptyString ;
33680 wxString *arg4 = (wxString *) &arg4_defvalue ;
33681 wxMenuItem *result;
33682 bool temp3 = false ;
33683 bool temp4 = false ;
33684 PyObject * obj0 = 0 ;
33685 PyObject * obj1 = 0 ;
33686 PyObject * obj2 = 0 ;
33687 PyObject * obj3 = 0 ;
33688 char *kwnames[] = {
33689 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33690 };
33691
33692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33694 if (SWIG_arg_fail(1)) SWIG_fail;
33695 {
33696 arg2 = (int)(SWIG_As_int(obj1));
33697 if (SWIG_arg_fail(2)) SWIG_fail;
33698 }
33699 {
33700 arg3 = wxString_in_helper(obj2);
33701 if (arg3 == NULL) SWIG_fail;
33702 temp3 = true;
33703 }
33704 if (obj3) {
33705 {
33706 arg4 = wxString_in_helper(obj3);
33707 if (arg4 == NULL) SWIG_fail;
33708 temp4 = true;
33709 }
33710 }
33711 {
33712 PyThreadState* __tstate = wxPyBeginAllowThreads();
33713 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33714
33715 wxPyEndAllowThreads(__tstate);
33716 if (PyErr_Occurred()) SWIG_fail;
33717 }
33718 {
33719 resultobj = wxPyMake_wxObject(result, 0);
33720 }
33721 {
33722 if (temp3)
33723 delete arg3;
33724 }
33725 {
33726 if (temp4)
33727 delete arg4;
33728 }
33729 return resultobj;
33730 fail:
33731 {
33732 if (temp3)
33733 delete arg3;
33734 }
33735 {
33736 if (temp4)
33737 delete arg4;
33738 }
33739 return NULL;
33740 }
33741
33742
33743 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33744 PyObject *resultobj;
33745 wxMenu *arg1 = (wxMenu *) 0 ;
33746 int arg2 ;
33747 wxString *arg3 = 0 ;
33748 wxMenu *arg4 = (wxMenu *) 0 ;
33749 wxString const &arg5_defvalue = wxPyEmptyString ;
33750 wxString *arg5 = (wxString *) &arg5_defvalue ;
33751 wxMenuItem *result;
33752 bool temp3 = false ;
33753 bool temp5 = false ;
33754 PyObject * obj0 = 0 ;
33755 PyObject * obj1 = 0 ;
33756 PyObject * obj2 = 0 ;
33757 PyObject * obj3 = 0 ;
33758 PyObject * obj4 = 0 ;
33759 char *kwnames[] = {
33760 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33761 };
33762
33763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33765 if (SWIG_arg_fail(1)) SWIG_fail;
33766 {
33767 arg2 = (int)(SWIG_As_int(obj1));
33768 if (SWIG_arg_fail(2)) SWIG_fail;
33769 }
33770 {
33771 arg3 = wxString_in_helper(obj2);
33772 if (arg3 == NULL) SWIG_fail;
33773 temp3 = true;
33774 }
33775 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33776 if (SWIG_arg_fail(4)) SWIG_fail;
33777 if (obj4) {
33778 {
33779 arg5 = wxString_in_helper(obj4);
33780 if (arg5 == NULL) SWIG_fail;
33781 temp5 = true;
33782 }
33783 }
33784 {
33785 PyThreadState* __tstate = wxPyBeginAllowThreads();
33786 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33787
33788 wxPyEndAllowThreads(__tstate);
33789 if (PyErr_Occurred()) SWIG_fail;
33790 }
33791 {
33792 resultobj = wxPyMake_wxObject(result, 0);
33793 }
33794 {
33795 if (temp3)
33796 delete arg3;
33797 }
33798 {
33799 if (temp5)
33800 delete arg5;
33801 }
33802 return resultobj;
33803 fail:
33804 {
33805 if (temp3)
33806 delete arg3;
33807 }
33808 {
33809 if (temp5)
33810 delete arg5;
33811 }
33812 return NULL;
33813 }
33814
33815
33816 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33817 PyObject *resultobj;
33818 wxMenu *arg1 = (wxMenu *) 0 ;
33819 int arg2 ;
33820 wxMenuItem *result;
33821 PyObject * obj0 = 0 ;
33822 PyObject * obj1 = 0 ;
33823 char *kwnames[] = {
33824 (char *) "self",(char *) "id", NULL
33825 };
33826
33827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33829 if (SWIG_arg_fail(1)) SWIG_fail;
33830 {
33831 arg2 = (int)(SWIG_As_int(obj1));
33832 if (SWIG_arg_fail(2)) SWIG_fail;
33833 }
33834 {
33835 PyThreadState* __tstate = wxPyBeginAllowThreads();
33836 result = (wxMenuItem *)(arg1)->Remove(arg2);
33837
33838 wxPyEndAllowThreads(__tstate);
33839 if (PyErr_Occurred()) SWIG_fail;
33840 }
33841 {
33842 resultobj = wxPyMake_wxObject(result, 0);
33843 }
33844 return resultobj;
33845 fail:
33846 return NULL;
33847 }
33848
33849
33850 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33851 PyObject *resultobj;
33852 wxMenu *arg1 = (wxMenu *) 0 ;
33853 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33854 wxMenuItem *result;
33855 PyObject * obj0 = 0 ;
33856 PyObject * obj1 = 0 ;
33857 char *kwnames[] = {
33858 (char *) "self",(char *) "item", NULL
33859 };
33860
33861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33863 if (SWIG_arg_fail(1)) SWIG_fail;
33864 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33865 if (SWIG_arg_fail(2)) SWIG_fail;
33866 {
33867 PyThreadState* __tstate = wxPyBeginAllowThreads();
33868 result = (wxMenuItem *)(arg1)->Remove(arg2);
33869
33870 wxPyEndAllowThreads(__tstate);
33871 if (PyErr_Occurred()) SWIG_fail;
33872 }
33873 {
33874 resultobj = wxPyMake_wxObject(result, 0);
33875 }
33876 return resultobj;
33877 fail:
33878 return NULL;
33879 }
33880
33881
33882 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33883 PyObject *resultobj;
33884 wxMenu *arg1 = (wxMenu *) 0 ;
33885 int arg2 ;
33886 bool result;
33887 PyObject * obj0 = 0 ;
33888 PyObject * obj1 = 0 ;
33889 char *kwnames[] = {
33890 (char *) "self",(char *) "id", NULL
33891 };
33892
33893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33895 if (SWIG_arg_fail(1)) SWIG_fail;
33896 {
33897 arg2 = (int)(SWIG_As_int(obj1));
33898 if (SWIG_arg_fail(2)) SWIG_fail;
33899 }
33900 {
33901 PyThreadState* __tstate = wxPyBeginAllowThreads();
33902 result = (bool)(arg1)->Delete(arg2);
33903
33904 wxPyEndAllowThreads(__tstate);
33905 if (PyErr_Occurred()) SWIG_fail;
33906 }
33907 {
33908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33909 }
33910 return resultobj;
33911 fail:
33912 return NULL;
33913 }
33914
33915
33916 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33917 PyObject *resultobj;
33918 wxMenu *arg1 = (wxMenu *) 0 ;
33919 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33920 bool result;
33921 PyObject * obj0 = 0 ;
33922 PyObject * obj1 = 0 ;
33923 char *kwnames[] = {
33924 (char *) "self",(char *) "item", NULL
33925 };
33926
33927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33929 if (SWIG_arg_fail(1)) SWIG_fail;
33930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33931 if (SWIG_arg_fail(2)) SWIG_fail;
33932 {
33933 PyThreadState* __tstate = wxPyBeginAllowThreads();
33934 result = (bool)(arg1)->Delete(arg2);
33935
33936 wxPyEndAllowThreads(__tstate);
33937 if (PyErr_Occurred()) SWIG_fail;
33938 }
33939 {
33940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33941 }
33942 return resultobj;
33943 fail:
33944 return NULL;
33945 }
33946
33947
33948 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33949 PyObject *resultobj;
33950 wxMenu *arg1 = (wxMenu *) 0 ;
33951 PyObject * obj0 = 0 ;
33952 char *kwnames[] = {
33953 (char *) "self", NULL
33954 };
33955
33956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33958 if (SWIG_arg_fail(1)) SWIG_fail;
33959 {
33960 PyThreadState* __tstate = wxPyBeginAllowThreads();
33961 wxMenu_Destroy(arg1);
33962
33963 wxPyEndAllowThreads(__tstate);
33964 if (PyErr_Occurred()) SWIG_fail;
33965 }
33966 Py_INCREF(Py_None); resultobj = Py_None;
33967 return resultobj;
33968 fail:
33969 return NULL;
33970 }
33971
33972
33973 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33974 PyObject *resultobj;
33975 wxMenu *arg1 = (wxMenu *) 0 ;
33976 int arg2 ;
33977 bool result;
33978 PyObject * obj0 = 0 ;
33979 PyObject * obj1 = 0 ;
33980 char *kwnames[] = {
33981 (char *) "self",(char *) "id", NULL
33982 };
33983
33984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33986 if (SWIG_arg_fail(1)) SWIG_fail;
33987 {
33988 arg2 = (int)(SWIG_As_int(obj1));
33989 if (SWIG_arg_fail(2)) SWIG_fail;
33990 }
33991 {
33992 PyThreadState* __tstate = wxPyBeginAllowThreads();
33993 result = (bool)(arg1)->Destroy(arg2);
33994
33995 wxPyEndAllowThreads(__tstate);
33996 if (PyErr_Occurred()) SWIG_fail;
33997 }
33998 {
33999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34000 }
34001 return resultobj;
34002 fail:
34003 return NULL;
34004 }
34005
34006
34007 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34008 PyObject *resultobj;
34009 wxMenu *arg1 = (wxMenu *) 0 ;
34010 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34011 bool result;
34012 PyObject * obj0 = 0 ;
34013 PyObject * obj1 = 0 ;
34014 char *kwnames[] = {
34015 (char *) "self",(char *) "item", NULL
34016 };
34017
34018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34020 if (SWIG_arg_fail(1)) SWIG_fail;
34021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34022 if (SWIG_arg_fail(2)) SWIG_fail;
34023 {
34024 PyThreadState* __tstate = wxPyBeginAllowThreads();
34025 result = (bool)(arg1)->Destroy(arg2);
34026
34027 wxPyEndAllowThreads(__tstate);
34028 if (PyErr_Occurred()) SWIG_fail;
34029 }
34030 {
34031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34032 }
34033 return resultobj;
34034 fail:
34035 return NULL;
34036 }
34037
34038
34039 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34040 PyObject *resultobj;
34041 wxMenu *arg1 = (wxMenu *) 0 ;
34042 size_t result;
34043 PyObject * obj0 = 0 ;
34044 char *kwnames[] = {
34045 (char *) "self", NULL
34046 };
34047
34048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34050 if (SWIG_arg_fail(1)) SWIG_fail;
34051 {
34052 PyThreadState* __tstate = wxPyBeginAllowThreads();
34053 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34054
34055 wxPyEndAllowThreads(__tstate);
34056 if (PyErr_Occurred()) SWIG_fail;
34057 }
34058 {
34059 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34060 }
34061 return resultobj;
34062 fail:
34063 return NULL;
34064 }
34065
34066
34067 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34068 PyObject *resultobj;
34069 wxMenu *arg1 = (wxMenu *) 0 ;
34070 PyObject *result;
34071 PyObject * obj0 = 0 ;
34072 char *kwnames[] = {
34073 (char *) "self", NULL
34074 };
34075
34076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34078 if (SWIG_arg_fail(1)) SWIG_fail;
34079 {
34080 PyThreadState* __tstate = wxPyBeginAllowThreads();
34081 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34082
34083 wxPyEndAllowThreads(__tstate);
34084 if (PyErr_Occurred()) SWIG_fail;
34085 }
34086 resultobj = result;
34087 return resultobj;
34088 fail:
34089 return NULL;
34090 }
34091
34092
34093 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34094 PyObject *resultobj;
34095 wxMenu *arg1 = (wxMenu *) 0 ;
34096 wxString *arg2 = 0 ;
34097 int result;
34098 bool temp2 = false ;
34099 PyObject * obj0 = 0 ;
34100 PyObject * obj1 = 0 ;
34101 char *kwnames[] = {
34102 (char *) "self",(char *) "item", NULL
34103 };
34104
34105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34107 if (SWIG_arg_fail(1)) SWIG_fail;
34108 {
34109 arg2 = wxString_in_helper(obj1);
34110 if (arg2 == NULL) SWIG_fail;
34111 temp2 = true;
34112 }
34113 {
34114 PyThreadState* __tstate = wxPyBeginAllowThreads();
34115 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34116
34117 wxPyEndAllowThreads(__tstate);
34118 if (PyErr_Occurred()) SWIG_fail;
34119 }
34120 {
34121 resultobj = SWIG_From_int((int)(result));
34122 }
34123 {
34124 if (temp2)
34125 delete arg2;
34126 }
34127 return resultobj;
34128 fail:
34129 {
34130 if (temp2)
34131 delete arg2;
34132 }
34133 return NULL;
34134 }
34135
34136
34137 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34138 PyObject *resultobj;
34139 wxMenu *arg1 = (wxMenu *) 0 ;
34140 int arg2 ;
34141 wxMenuItem *result;
34142 PyObject * obj0 = 0 ;
34143 PyObject * obj1 = 0 ;
34144 char *kwnames[] = {
34145 (char *) "self",(char *) "id", NULL
34146 };
34147
34148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34150 if (SWIG_arg_fail(1)) SWIG_fail;
34151 {
34152 arg2 = (int)(SWIG_As_int(obj1));
34153 if (SWIG_arg_fail(2)) SWIG_fail;
34154 }
34155 {
34156 PyThreadState* __tstate = wxPyBeginAllowThreads();
34157 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34158
34159 wxPyEndAllowThreads(__tstate);
34160 if (PyErr_Occurred()) SWIG_fail;
34161 }
34162 {
34163 resultobj = wxPyMake_wxObject(result, 0);
34164 }
34165 return resultobj;
34166 fail:
34167 return NULL;
34168 }
34169
34170
34171 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34172 PyObject *resultobj;
34173 wxMenu *arg1 = (wxMenu *) 0 ;
34174 size_t arg2 ;
34175 wxMenuItem *result;
34176 PyObject * obj0 = 0 ;
34177 PyObject * obj1 = 0 ;
34178 char *kwnames[] = {
34179 (char *) "self",(char *) "position", NULL
34180 };
34181
34182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34184 if (SWIG_arg_fail(1)) SWIG_fail;
34185 {
34186 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34187 if (SWIG_arg_fail(2)) SWIG_fail;
34188 }
34189 {
34190 PyThreadState* __tstate = wxPyBeginAllowThreads();
34191 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34192
34193 wxPyEndAllowThreads(__tstate);
34194 if (PyErr_Occurred()) SWIG_fail;
34195 }
34196 {
34197 resultobj = wxPyMake_wxObject(result, 0);
34198 }
34199 return resultobj;
34200 fail:
34201 return NULL;
34202 }
34203
34204
34205 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34206 PyObject *resultobj;
34207 wxMenu *arg1 = (wxMenu *) 0 ;
34208 int arg2 ;
34209 bool arg3 ;
34210 PyObject * obj0 = 0 ;
34211 PyObject * obj1 = 0 ;
34212 PyObject * obj2 = 0 ;
34213 char *kwnames[] = {
34214 (char *) "self",(char *) "id",(char *) "enable", NULL
34215 };
34216
34217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34219 if (SWIG_arg_fail(1)) SWIG_fail;
34220 {
34221 arg2 = (int)(SWIG_As_int(obj1));
34222 if (SWIG_arg_fail(2)) SWIG_fail;
34223 }
34224 {
34225 arg3 = (bool)(SWIG_As_bool(obj2));
34226 if (SWIG_arg_fail(3)) SWIG_fail;
34227 }
34228 {
34229 PyThreadState* __tstate = wxPyBeginAllowThreads();
34230 (arg1)->Enable(arg2,arg3);
34231
34232 wxPyEndAllowThreads(__tstate);
34233 if (PyErr_Occurred()) SWIG_fail;
34234 }
34235 Py_INCREF(Py_None); resultobj = Py_None;
34236 return resultobj;
34237 fail:
34238 return NULL;
34239 }
34240
34241
34242 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34243 PyObject *resultobj;
34244 wxMenu *arg1 = (wxMenu *) 0 ;
34245 int arg2 ;
34246 bool result;
34247 PyObject * obj0 = 0 ;
34248 PyObject * obj1 = 0 ;
34249 char *kwnames[] = {
34250 (char *) "self",(char *) "id", NULL
34251 };
34252
34253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34255 if (SWIG_arg_fail(1)) SWIG_fail;
34256 {
34257 arg2 = (int)(SWIG_As_int(obj1));
34258 if (SWIG_arg_fail(2)) SWIG_fail;
34259 }
34260 {
34261 PyThreadState* __tstate = wxPyBeginAllowThreads();
34262 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34263
34264 wxPyEndAllowThreads(__tstate);
34265 if (PyErr_Occurred()) SWIG_fail;
34266 }
34267 {
34268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34269 }
34270 return resultobj;
34271 fail:
34272 return NULL;
34273 }
34274
34275
34276 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34277 PyObject *resultobj;
34278 wxMenu *arg1 = (wxMenu *) 0 ;
34279 int arg2 ;
34280 bool arg3 ;
34281 PyObject * obj0 = 0 ;
34282 PyObject * obj1 = 0 ;
34283 PyObject * obj2 = 0 ;
34284 char *kwnames[] = {
34285 (char *) "self",(char *) "id",(char *) "check", NULL
34286 };
34287
34288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = (int)(SWIG_As_int(obj1));
34293 if (SWIG_arg_fail(2)) SWIG_fail;
34294 }
34295 {
34296 arg3 = (bool)(SWIG_As_bool(obj2));
34297 if (SWIG_arg_fail(3)) SWIG_fail;
34298 }
34299 {
34300 PyThreadState* __tstate = wxPyBeginAllowThreads();
34301 (arg1)->Check(arg2,arg3);
34302
34303 wxPyEndAllowThreads(__tstate);
34304 if (PyErr_Occurred()) SWIG_fail;
34305 }
34306 Py_INCREF(Py_None); resultobj = Py_None;
34307 return resultobj;
34308 fail:
34309 return NULL;
34310 }
34311
34312
34313 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34314 PyObject *resultobj;
34315 wxMenu *arg1 = (wxMenu *) 0 ;
34316 int arg2 ;
34317 bool result;
34318 PyObject * obj0 = 0 ;
34319 PyObject * obj1 = 0 ;
34320 char *kwnames[] = {
34321 (char *) "self",(char *) "id", NULL
34322 };
34323
34324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34326 if (SWIG_arg_fail(1)) SWIG_fail;
34327 {
34328 arg2 = (int)(SWIG_As_int(obj1));
34329 if (SWIG_arg_fail(2)) SWIG_fail;
34330 }
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34334
34335 wxPyEndAllowThreads(__tstate);
34336 if (PyErr_Occurred()) SWIG_fail;
34337 }
34338 {
34339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34340 }
34341 return resultobj;
34342 fail:
34343 return NULL;
34344 }
34345
34346
34347 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34348 PyObject *resultobj;
34349 wxMenu *arg1 = (wxMenu *) 0 ;
34350 int arg2 ;
34351 wxString *arg3 = 0 ;
34352 bool temp3 = false ;
34353 PyObject * obj0 = 0 ;
34354 PyObject * obj1 = 0 ;
34355 PyObject * obj2 = 0 ;
34356 char *kwnames[] = {
34357 (char *) "self",(char *) "id",(char *) "label", NULL
34358 };
34359
34360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34362 if (SWIG_arg_fail(1)) SWIG_fail;
34363 {
34364 arg2 = (int)(SWIG_As_int(obj1));
34365 if (SWIG_arg_fail(2)) SWIG_fail;
34366 }
34367 {
34368 arg3 = wxString_in_helper(obj2);
34369 if (arg3 == NULL) SWIG_fail;
34370 temp3 = true;
34371 }
34372 {
34373 PyThreadState* __tstate = wxPyBeginAllowThreads();
34374 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34375
34376 wxPyEndAllowThreads(__tstate);
34377 if (PyErr_Occurred()) SWIG_fail;
34378 }
34379 Py_INCREF(Py_None); resultobj = Py_None;
34380 {
34381 if (temp3)
34382 delete arg3;
34383 }
34384 return resultobj;
34385 fail:
34386 {
34387 if (temp3)
34388 delete arg3;
34389 }
34390 return NULL;
34391 }
34392
34393
34394 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34395 PyObject *resultobj;
34396 wxMenu *arg1 = (wxMenu *) 0 ;
34397 int arg2 ;
34398 wxString result;
34399 PyObject * obj0 = 0 ;
34400 PyObject * obj1 = 0 ;
34401 char *kwnames[] = {
34402 (char *) "self",(char *) "id", NULL
34403 };
34404
34405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34407 if (SWIG_arg_fail(1)) SWIG_fail;
34408 {
34409 arg2 = (int)(SWIG_As_int(obj1));
34410 if (SWIG_arg_fail(2)) SWIG_fail;
34411 }
34412 {
34413 PyThreadState* __tstate = wxPyBeginAllowThreads();
34414 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34415
34416 wxPyEndAllowThreads(__tstate);
34417 if (PyErr_Occurred()) SWIG_fail;
34418 }
34419 {
34420 #if wxUSE_UNICODE
34421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34422 #else
34423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34424 #endif
34425 }
34426 return resultobj;
34427 fail:
34428 return NULL;
34429 }
34430
34431
34432 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34433 PyObject *resultobj;
34434 wxMenu *arg1 = (wxMenu *) 0 ;
34435 int arg2 ;
34436 wxString *arg3 = 0 ;
34437 bool temp3 = false ;
34438 PyObject * obj0 = 0 ;
34439 PyObject * obj1 = 0 ;
34440 PyObject * obj2 = 0 ;
34441 char *kwnames[] = {
34442 (char *) "self",(char *) "id",(char *) "helpString", NULL
34443 };
34444
34445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34447 if (SWIG_arg_fail(1)) SWIG_fail;
34448 {
34449 arg2 = (int)(SWIG_As_int(obj1));
34450 if (SWIG_arg_fail(2)) SWIG_fail;
34451 }
34452 {
34453 arg3 = wxString_in_helper(obj2);
34454 if (arg3 == NULL) SWIG_fail;
34455 temp3 = true;
34456 }
34457 {
34458 PyThreadState* __tstate = wxPyBeginAllowThreads();
34459 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34460
34461 wxPyEndAllowThreads(__tstate);
34462 if (PyErr_Occurred()) SWIG_fail;
34463 }
34464 Py_INCREF(Py_None); resultobj = Py_None;
34465 {
34466 if (temp3)
34467 delete arg3;
34468 }
34469 return resultobj;
34470 fail:
34471 {
34472 if (temp3)
34473 delete arg3;
34474 }
34475 return NULL;
34476 }
34477
34478
34479 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34480 PyObject *resultobj;
34481 wxMenu *arg1 = (wxMenu *) 0 ;
34482 int arg2 ;
34483 wxString result;
34484 PyObject * obj0 = 0 ;
34485 PyObject * obj1 = 0 ;
34486 char *kwnames[] = {
34487 (char *) "self",(char *) "id", NULL
34488 };
34489
34490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34492 if (SWIG_arg_fail(1)) SWIG_fail;
34493 {
34494 arg2 = (int)(SWIG_As_int(obj1));
34495 if (SWIG_arg_fail(2)) SWIG_fail;
34496 }
34497 {
34498 PyThreadState* __tstate = wxPyBeginAllowThreads();
34499 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34500
34501 wxPyEndAllowThreads(__tstate);
34502 if (PyErr_Occurred()) SWIG_fail;
34503 }
34504 {
34505 #if wxUSE_UNICODE
34506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34507 #else
34508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34509 #endif
34510 }
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34518 PyObject *resultobj;
34519 wxMenu *arg1 = (wxMenu *) 0 ;
34520 wxString *arg2 = 0 ;
34521 bool temp2 = false ;
34522 PyObject * obj0 = 0 ;
34523 PyObject * obj1 = 0 ;
34524 char *kwnames[] = {
34525 (char *) "self",(char *) "title", NULL
34526 };
34527
34528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34530 if (SWIG_arg_fail(1)) SWIG_fail;
34531 {
34532 arg2 = wxString_in_helper(obj1);
34533 if (arg2 == NULL) SWIG_fail;
34534 temp2 = true;
34535 }
34536 {
34537 PyThreadState* __tstate = wxPyBeginAllowThreads();
34538 (arg1)->SetTitle((wxString const &)*arg2);
34539
34540 wxPyEndAllowThreads(__tstate);
34541 if (PyErr_Occurred()) SWIG_fail;
34542 }
34543 Py_INCREF(Py_None); resultobj = Py_None;
34544 {
34545 if (temp2)
34546 delete arg2;
34547 }
34548 return resultobj;
34549 fail:
34550 {
34551 if (temp2)
34552 delete arg2;
34553 }
34554 return NULL;
34555 }
34556
34557
34558 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34559 PyObject *resultobj;
34560 wxMenu *arg1 = (wxMenu *) 0 ;
34561 wxString result;
34562 PyObject * obj0 = 0 ;
34563 char *kwnames[] = {
34564 (char *) "self", NULL
34565 };
34566
34567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34569 if (SWIG_arg_fail(1)) SWIG_fail;
34570 {
34571 PyThreadState* __tstate = wxPyBeginAllowThreads();
34572 result = ((wxMenu const *)arg1)->GetTitle();
34573
34574 wxPyEndAllowThreads(__tstate);
34575 if (PyErr_Occurred()) SWIG_fail;
34576 }
34577 {
34578 #if wxUSE_UNICODE
34579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34580 #else
34581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34582 #endif
34583 }
34584 return resultobj;
34585 fail:
34586 return NULL;
34587 }
34588
34589
34590 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34591 PyObject *resultobj;
34592 wxMenu *arg1 = (wxMenu *) 0 ;
34593 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34594 PyObject * obj0 = 0 ;
34595 PyObject * obj1 = 0 ;
34596 char *kwnames[] = {
34597 (char *) "self",(char *) "handler", NULL
34598 };
34599
34600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34602 if (SWIG_arg_fail(1)) SWIG_fail;
34603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34604 if (SWIG_arg_fail(2)) SWIG_fail;
34605 {
34606 PyThreadState* __tstate = wxPyBeginAllowThreads();
34607 (arg1)->SetEventHandler(arg2);
34608
34609 wxPyEndAllowThreads(__tstate);
34610 if (PyErr_Occurred()) SWIG_fail;
34611 }
34612 Py_INCREF(Py_None); resultobj = Py_None;
34613 return resultobj;
34614 fail:
34615 return NULL;
34616 }
34617
34618
34619 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34620 PyObject *resultobj;
34621 wxMenu *arg1 = (wxMenu *) 0 ;
34622 wxEvtHandler *result;
34623 PyObject * obj0 = 0 ;
34624 char *kwnames[] = {
34625 (char *) "self", NULL
34626 };
34627
34628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34630 if (SWIG_arg_fail(1)) SWIG_fail;
34631 {
34632 PyThreadState* __tstate = wxPyBeginAllowThreads();
34633 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34634
34635 wxPyEndAllowThreads(__tstate);
34636 if (PyErr_Occurred()) SWIG_fail;
34637 }
34638 {
34639 resultobj = wxPyMake_wxObject(result, 0);
34640 }
34641 return resultobj;
34642 fail:
34643 return NULL;
34644 }
34645
34646
34647 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34648 PyObject *resultobj;
34649 wxMenu *arg1 = (wxMenu *) 0 ;
34650 wxWindow *arg2 = (wxWindow *) 0 ;
34651 PyObject * obj0 = 0 ;
34652 PyObject * obj1 = 0 ;
34653 char *kwnames[] = {
34654 (char *) "self",(char *) "win", NULL
34655 };
34656
34657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34659 if (SWIG_arg_fail(1)) SWIG_fail;
34660 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34661 if (SWIG_arg_fail(2)) SWIG_fail;
34662 {
34663 PyThreadState* __tstate = wxPyBeginAllowThreads();
34664 (arg1)->SetInvokingWindow(arg2);
34665
34666 wxPyEndAllowThreads(__tstate);
34667 if (PyErr_Occurred()) SWIG_fail;
34668 }
34669 Py_INCREF(Py_None); resultobj = Py_None;
34670 return resultobj;
34671 fail:
34672 return NULL;
34673 }
34674
34675
34676 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34677 PyObject *resultobj;
34678 wxMenu *arg1 = (wxMenu *) 0 ;
34679 wxWindow *result;
34680 PyObject * obj0 = 0 ;
34681 char *kwnames[] = {
34682 (char *) "self", NULL
34683 };
34684
34685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34687 if (SWIG_arg_fail(1)) SWIG_fail;
34688 {
34689 PyThreadState* __tstate = wxPyBeginAllowThreads();
34690 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34691
34692 wxPyEndAllowThreads(__tstate);
34693 if (PyErr_Occurred()) SWIG_fail;
34694 }
34695 {
34696 resultobj = wxPyMake_wxObject(result, 0);
34697 }
34698 return resultobj;
34699 fail:
34700 return NULL;
34701 }
34702
34703
34704 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34705 PyObject *resultobj;
34706 wxMenu *arg1 = (wxMenu *) 0 ;
34707 long result;
34708 PyObject * obj0 = 0 ;
34709 char *kwnames[] = {
34710 (char *) "self", NULL
34711 };
34712
34713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34715 if (SWIG_arg_fail(1)) SWIG_fail;
34716 {
34717 PyThreadState* __tstate = wxPyBeginAllowThreads();
34718 result = (long)((wxMenu const *)arg1)->GetStyle();
34719
34720 wxPyEndAllowThreads(__tstate);
34721 if (PyErr_Occurred()) SWIG_fail;
34722 }
34723 {
34724 resultobj = SWIG_From_long((long)(result));
34725 }
34726 return resultobj;
34727 fail:
34728 return NULL;
34729 }
34730
34731
34732 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34733 PyObject *resultobj;
34734 wxMenu *arg1 = (wxMenu *) 0 ;
34735 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34736 PyObject * obj0 = 0 ;
34737 PyObject * obj1 = 0 ;
34738 char *kwnames[] = {
34739 (char *) "self",(char *) "source", NULL
34740 };
34741
34742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34744 if (SWIG_arg_fail(1)) SWIG_fail;
34745 if (obj1) {
34746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34747 if (SWIG_arg_fail(2)) SWIG_fail;
34748 }
34749 {
34750 PyThreadState* __tstate = wxPyBeginAllowThreads();
34751 (arg1)->UpdateUI(arg2);
34752
34753 wxPyEndAllowThreads(__tstate);
34754 if (PyErr_Occurred()) SWIG_fail;
34755 }
34756 Py_INCREF(Py_None); resultobj = Py_None;
34757 return resultobj;
34758 fail:
34759 return NULL;
34760 }
34761
34762
34763 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34764 PyObject *resultobj;
34765 wxMenu *arg1 = (wxMenu *) 0 ;
34766 wxMenuBar *result;
34767 PyObject * obj0 = 0 ;
34768 char *kwnames[] = {
34769 (char *) "self", NULL
34770 };
34771
34772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34774 if (SWIG_arg_fail(1)) SWIG_fail;
34775 {
34776 PyThreadState* __tstate = wxPyBeginAllowThreads();
34777 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34778
34779 wxPyEndAllowThreads(__tstate);
34780 if (PyErr_Occurred()) SWIG_fail;
34781 }
34782 {
34783 resultobj = wxPyMake_wxObject(result, 0);
34784 }
34785 return resultobj;
34786 fail:
34787 return NULL;
34788 }
34789
34790
34791 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34792 PyObject *resultobj;
34793 wxMenu *arg1 = (wxMenu *) 0 ;
34794 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34795 PyObject * obj0 = 0 ;
34796 PyObject * obj1 = 0 ;
34797 char *kwnames[] = {
34798 (char *) "self",(char *) "menubar", NULL
34799 };
34800
34801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34803 if (SWIG_arg_fail(1)) SWIG_fail;
34804 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34805 if (SWIG_arg_fail(2)) SWIG_fail;
34806 {
34807 PyThreadState* __tstate = wxPyBeginAllowThreads();
34808 (arg1)->Attach(arg2);
34809
34810 wxPyEndAllowThreads(__tstate);
34811 if (PyErr_Occurred()) SWIG_fail;
34812 }
34813 Py_INCREF(Py_None); resultobj = Py_None;
34814 return resultobj;
34815 fail:
34816 return NULL;
34817 }
34818
34819
34820 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34821 PyObject *resultobj;
34822 wxMenu *arg1 = (wxMenu *) 0 ;
34823 PyObject * obj0 = 0 ;
34824 char *kwnames[] = {
34825 (char *) "self", NULL
34826 };
34827
34828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34830 if (SWIG_arg_fail(1)) SWIG_fail;
34831 {
34832 PyThreadState* __tstate = wxPyBeginAllowThreads();
34833 (arg1)->Detach();
34834
34835 wxPyEndAllowThreads(__tstate);
34836 if (PyErr_Occurred()) SWIG_fail;
34837 }
34838 Py_INCREF(Py_None); resultobj = Py_None;
34839 return resultobj;
34840 fail:
34841 return NULL;
34842 }
34843
34844
34845 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34846 PyObject *resultobj;
34847 wxMenu *arg1 = (wxMenu *) 0 ;
34848 bool result;
34849 PyObject * obj0 = 0 ;
34850 char *kwnames[] = {
34851 (char *) "self", NULL
34852 };
34853
34854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34856 if (SWIG_arg_fail(1)) SWIG_fail;
34857 {
34858 PyThreadState* __tstate = wxPyBeginAllowThreads();
34859 result = (bool)((wxMenu const *)arg1)->IsAttached();
34860
34861 wxPyEndAllowThreads(__tstate);
34862 if (PyErr_Occurred()) SWIG_fail;
34863 }
34864 {
34865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34866 }
34867 return resultobj;
34868 fail:
34869 return NULL;
34870 }
34871
34872
34873 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34874 PyObject *resultobj;
34875 wxMenu *arg1 = (wxMenu *) 0 ;
34876 wxMenu *arg2 = (wxMenu *) 0 ;
34877 PyObject * obj0 = 0 ;
34878 PyObject * obj1 = 0 ;
34879 char *kwnames[] = {
34880 (char *) "self",(char *) "parent", NULL
34881 };
34882
34883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34885 if (SWIG_arg_fail(1)) SWIG_fail;
34886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34887 if (SWIG_arg_fail(2)) SWIG_fail;
34888 {
34889 PyThreadState* __tstate = wxPyBeginAllowThreads();
34890 (arg1)->SetParent(arg2);
34891
34892 wxPyEndAllowThreads(__tstate);
34893 if (PyErr_Occurred()) SWIG_fail;
34894 }
34895 Py_INCREF(Py_None); resultobj = Py_None;
34896 return resultobj;
34897 fail:
34898 return NULL;
34899 }
34900
34901
34902 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34903 PyObject *resultobj;
34904 wxMenu *arg1 = (wxMenu *) 0 ;
34905 wxMenu *result;
34906 PyObject * obj0 = 0 ;
34907 char *kwnames[] = {
34908 (char *) "self", NULL
34909 };
34910
34911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34913 if (SWIG_arg_fail(1)) SWIG_fail;
34914 {
34915 PyThreadState* __tstate = wxPyBeginAllowThreads();
34916 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34917
34918 wxPyEndAllowThreads(__tstate);
34919 if (PyErr_Occurred()) SWIG_fail;
34920 }
34921 {
34922 resultobj = wxPyMake_wxObject(result, 0);
34923 }
34924 return resultobj;
34925 fail:
34926 return NULL;
34927 }
34928
34929
34930 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34931 PyObject *obj;
34932 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34933 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34934 Py_INCREF(obj);
34935 return Py_BuildValue((char *)"");
34936 }
34937 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34938 PyObject *resultobj;
34939 long arg1 = (long) 0 ;
34940 wxMenuBar *result;
34941 PyObject * obj0 = 0 ;
34942 char *kwnames[] = {
34943 (char *) "style", NULL
34944 };
34945
34946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34947 if (obj0) {
34948 {
34949 arg1 = (long)(SWIG_As_long(obj0));
34950 if (SWIG_arg_fail(1)) SWIG_fail;
34951 }
34952 }
34953 {
34954 if (!wxPyCheckForApp()) SWIG_fail;
34955 PyThreadState* __tstate = wxPyBeginAllowThreads();
34956 result = (wxMenuBar *)new wxMenuBar(arg1);
34957
34958 wxPyEndAllowThreads(__tstate);
34959 if (PyErr_Occurred()) SWIG_fail;
34960 }
34961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34962 return resultobj;
34963 fail:
34964 return NULL;
34965 }
34966
34967
34968 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34969 PyObject *resultobj;
34970 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34971 wxMenu *arg2 = (wxMenu *) 0 ;
34972 wxString *arg3 = 0 ;
34973 bool result;
34974 bool temp3 = false ;
34975 PyObject * obj0 = 0 ;
34976 PyObject * obj1 = 0 ;
34977 PyObject * obj2 = 0 ;
34978 char *kwnames[] = {
34979 (char *) "self",(char *) "menu",(char *) "title", NULL
34980 };
34981
34982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34984 if (SWIG_arg_fail(1)) SWIG_fail;
34985 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34986 if (SWIG_arg_fail(2)) SWIG_fail;
34987 {
34988 arg3 = wxString_in_helper(obj2);
34989 if (arg3 == NULL) SWIG_fail;
34990 temp3 = true;
34991 }
34992 {
34993 PyThreadState* __tstate = wxPyBeginAllowThreads();
34994 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34995
34996 wxPyEndAllowThreads(__tstate);
34997 if (PyErr_Occurred()) SWIG_fail;
34998 }
34999 {
35000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35001 }
35002 {
35003 if (temp3)
35004 delete arg3;
35005 }
35006 return resultobj;
35007 fail:
35008 {
35009 if (temp3)
35010 delete arg3;
35011 }
35012 return NULL;
35013 }
35014
35015
35016 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35017 PyObject *resultobj;
35018 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35019 size_t arg2 ;
35020 wxMenu *arg3 = (wxMenu *) 0 ;
35021 wxString *arg4 = 0 ;
35022 bool result;
35023 bool temp4 = false ;
35024 PyObject * obj0 = 0 ;
35025 PyObject * obj1 = 0 ;
35026 PyObject * obj2 = 0 ;
35027 PyObject * obj3 = 0 ;
35028 char *kwnames[] = {
35029 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35030 };
35031
35032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35034 if (SWIG_arg_fail(1)) SWIG_fail;
35035 {
35036 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35037 if (SWIG_arg_fail(2)) SWIG_fail;
35038 }
35039 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35040 if (SWIG_arg_fail(3)) SWIG_fail;
35041 {
35042 arg4 = wxString_in_helper(obj3);
35043 if (arg4 == NULL) SWIG_fail;
35044 temp4 = true;
35045 }
35046 {
35047 PyThreadState* __tstate = wxPyBeginAllowThreads();
35048 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35049
35050 wxPyEndAllowThreads(__tstate);
35051 if (PyErr_Occurred()) SWIG_fail;
35052 }
35053 {
35054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35055 }
35056 {
35057 if (temp4)
35058 delete arg4;
35059 }
35060 return resultobj;
35061 fail:
35062 {
35063 if (temp4)
35064 delete arg4;
35065 }
35066 return NULL;
35067 }
35068
35069
35070 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35071 PyObject *resultobj;
35072 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35073 size_t result;
35074 PyObject * obj0 = 0 ;
35075 char *kwnames[] = {
35076 (char *) "self", NULL
35077 };
35078
35079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35081 if (SWIG_arg_fail(1)) SWIG_fail;
35082 {
35083 PyThreadState* __tstate = wxPyBeginAllowThreads();
35084 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35085
35086 wxPyEndAllowThreads(__tstate);
35087 if (PyErr_Occurred()) SWIG_fail;
35088 }
35089 {
35090 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35091 }
35092 return resultobj;
35093 fail:
35094 return NULL;
35095 }
35096
35097
35098 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35099 PyObject *resultobj;
35100 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35101 size_t arg2 ;
35102 wxMenu *result;
35103 PyObject * obj0 = 0 ;
35104 PyObject * obj1 = 0 ;
35105 char *kwnames[] = {
35106 (char *) "self",(char *) "pos", NULL
35107 };
35108
35109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35111 if (SWIG_arg_fail(1)) SWIG_fail;
35112 {
35113 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35114 if (SWIG_arg_fail(2)) SWIG_fail;
35115 }
35116 {
35117 PyThreadState* __tstate = wxPyBeginAllowThreads();
35118 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35119
35120 wxPyEndAllowThreads(__tstate);
35121 if (PyErr_Occurred()) SWIG_fail;
35122 }
35123 {
35124 resultobj = wxPyMake_wxObject(result, 0);
35125 }
35126 return resultobj;
35127 fail:
35128 return NULL;
35129 }
35130
35131
35132 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35133 PyObject *resultobj;
35134 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35135 size_t arg2 ;
35136 wxMenu *arg3 = (wxMenu *) 0 ;
35137 wxString *arg4 = 0 ;
35138 wxMenu *result;
35139 bool temp4 = false ;
35140 PyObject * obj0 = 0 ;
35141 PyObject * obj1 = 0 ;
35142 PyObject * obj2 = 0 ;
35143 PyObject * obj3 = 0 ;
35144 char *kwnames[] = {
35145 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35146 };
35147
35148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35153 if (SWIG_arg_fail(2)) SWIG_fail;
35154 }
35155 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35156 if (SWIG_arg_fail(3)) SWIG_fail;
35157 {
35158 arg4 = wxString_in_helper(obj3);
35159 if (arg4 == NULL) SWIG_fail;
35160 temp4 = true;
35161 }
35162 {
35163 PyThreadState* __tstate = wxPyBeginAllowThreads();
35164 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35165
35166 wxPyEndAllowThreads(__tstate);
35167 if (PyErr_Occurred()) SWIG_fail;
35168 }
35169 {
35170 resultobj = wxPyMake_wxObject(result, 0);
35171 }
35172 {
35173 if (temp4)
35174 delete arg4;
35175 }
35176 return resultobj;
35177 fail:
35178 {
35179 if (temp4)
35180 delete arg4;
35181 }
35182 return NULL;
35183 }
35184
35185
35186 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35187 PyObject *resultobj;
35188 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35189 size_t arg2 ;
35190 wxMenu *result;
35191 PyObject * obj0 = 0 ;
35192 PyObject * obj1 = 0 ;
35193 char *kwnames[] = {
35194 (char *) "self",(char *) "pos", NULL
35195 };
35196
35197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35199 if (SWIG_arg_fail(1)) SWIG_fail;
35200 {
35201 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35202 if (SWIG_arg_fail(2)) SWIG_fail;
35203 }
35204 {
35205 PyThreadState* __tstate = wxPyBeginAllowThreads();
35206 result = (wxMenu *)(arg1)->Remove(arg2);
35207
35208 wxPyEndAllowThreads(__tstate);
35209 if (PyErr_Occurred()) SWIG_fail;
35210 }
35211 {
35212 resultobj = wxPyMake_wxObject(result, 0);
35213 }
35214 return resultobj;
35215 fail:
35216 return NULL;
35217 }
35218
35219
35220 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35221 PyObject *resultobj;
35222 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35223 size_t arg2 ;
35224 bool arg3 ;
35225 PyObject * obj0 = 0 ;
35226 PyObject * obj1 = 0 ;
35227 PyObject * obj2 = 0 ;
35228 char *kwnames[] = {
35229 (char *) "self",(char *) "pos",(char *) "enable", NULL
35230 };
35231
35232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35234 if (SWIG_arg_fail(1)) SWIG_fail;
35235 {
35236 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35237 if (SWIG_arg_fail(2)) SWIG_fail;
35238 }
35239 {
35240 arg3 = (bool)(SWIG_As_bool(obj2));
35241 if (SWIG_arg_fail(3)) SWIG_fail;
35242 }
35243 {
35244 PyThreadState* __tstate = wxPyBeginAllowThreads();
35245 (arg1)->EnableTop(arg2,arg3);
35246
35247 wxPyEndAllowThreads(__tstate);
35248 if (PyErr_Occurred()) SWIG_fail;
35249 }
35250 Py_INCREF(Py_None); resultobj = Py_None;
35251 return resultobj;
35252 fail:
35253 return NULL;
35254 }
35255
35256
35257 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35258 PyObject *resultobj;
35259 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35260 size_t arg2 ;
35261 bool result;
35262 PyObject * obj0 = 0 ;
35263 PyObject * obj1 = 0 ;
35264 char *kwnames[] = {
35265 (char *) "self",(char *) "pos", NULL
35266 };
35267
35268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35270 if (SWIG_arg_fail(1)) SWIG_fail;
35271 {
35272 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35273 if (SWIG_arg_fail(2)) SWIG_fail;
35274 }
35275 {
35276 PyThreadState* __tstate = wxPyBeginAllowThreads();
35277 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35278
35279 wxPyEndAllowThreads(__tstate);
35280 if (PyErr_Occurred()) SWIG_fail;
35281 }
35282 {
35283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35284 }
35285 return resultobj;
35286 fail:
35287 return NULL;
35288 }
35289
35290
35291 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35292 PyObject *resultobj;
35293 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35294 size_t arg2 ;
35295 wxString *arg3 = 0 ;
35296 bool temp3 = false ;
35297 PyObject * obj0 = 0 ;
35298 PyObject * obj1 = 0 ;
35299 PyObject * obj2 = 0 ;
35300 char *kwnames[] = {
35301 (char *) "self",(char *) "pos",(char *) "label", NULL
35302 };
35303
35304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35306 if (SWIG_arg_fail(1)) SWIG_fail;
35307 {
35308 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35309 if (SWIG_arg_fail(2)) SWIG_fail;
35310 }
35311 {
35312 arg3 = wxString_in_helper(obj2);
35313 if (arg3 == NULL) SWIG_fail;
35314 temp3 = true;
35315 }
35316 {
35317 PyThreadState* __tstate = wxPyBeginAllowThreads();
35318 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35319
35320 wxPyEndAllowThreads(__tstate);
35321 if (PyErr_Occurred()) SWIG_fail;
35322 }
35323 Py_INCREF(Py_None); resultobj = Py_None;
35324 {
35325 if (temp3)
35326 delete arg3;
35327 }
35328 return resultobj;
35329 fail:
35330 {
35331 if (temp3)
35332 delete arg3;
35333 }
35334 return NULL;
35335 }
35336
35337
35338 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35339 PyObject *resultobj;
35340 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35341 size_t arg2 ;
35342 wxString result;
35343 PyObject * obj0 = 0 ;
35344 PyObject * obj1 = 0 ;
35345 char *kwnames[] = {
35346 (char *) "self",(char *) "pos", NULL
35347 };
35348
35349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35351 if (SWIG_arg_fail(1)) SWIG_fail;
35352 {
35353 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35354 if (SWIG_arg_fail(2)) SWIG_fail;
35355 }
35356 {
35357 PyThreadState* __tstate = wxPyBeginAllowThreads();
35358 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35359
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 {
35364 #if wxUSE_UNICODE
35365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35366 #else
35367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35368 #endif
35369 }
35370 return resultobj;
35371 fail:
35372 return NULL;
35373 }
35374
35375
35376 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35377 PyObject *resultobj;
35378 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35379 wxString *arg2 = 0 ;
35380 wxString *arg3 = 0 ;
35381 int result;
35382 bool temp2 = false ;
35383 bool temp3 = false ;
35384 PyObject * obj0 = 0 ;
35385 PyObject * obj1 = 0 ;
35386 PyObject * obj2 = 0 ;
35387 char *kwnames[] = {
35388 (char *) "self",(char *) "menu",(char *) "item", NULL
35389 };
35390
35391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35393 if (SWIG_arg_fail(1)) SWIG_fail;
35394 {
35395 arg2 = wxString_in_helper(obj1);
35396 if (arg2 == NULL) SWIG_fail;
35397 temp2 = true;
35398 }
35399 {
35400 arg3 = wxString_in_helper(obj2);
35401 if (arg3 == NULL) SWIG_fail;
35402 temp3 = true;
35403 }
35404 {
35405 PyThreadState* __tstate = wxPyBeginAllowThreads();
35406 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35407
35408 wxPyEndAllowThreads(__tstate);
35409 if (PyErr_Occurred()) SWIG_fail;
35410 }
35411 {
35412 resultobj = SWIG_From_int((int)(result));
35413 }
35414 {
35415 if (temp2)
35416 delete arg2;
35417 }
35418 {
35419 if (temp3)
35420 delete arg3;
35421 }
35422 return resultobj;
35423 fail:
35424 {
35425 if (temp2)
35426 delete arg2;
35427 }
35428 {
35429 if (temp3)
35430 delete arg3;
35431 }
35432 return NULL;
35433 }
35434
35435
35436 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35437 PyObject *resultobj;
35438 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35439 int arg2 ;
35440 wxMenuItem *result;
35441 PyObject * obj0 = 0 ;
35442 PyObject * obj1 = 0 ;
35443 char *kwnames[] = {
35444 (char *) "self",(char *) "id", NULL
35445 };
35446
35447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35449 if (SWIG_arg_fail(1)) SWIG_fail;
35450 {
35451 arg2 = (int)(SWIG_As_int(obj1));
35452 if (SWIG_arg_fail(2)) SWIG_fail;
35453 }
35454 {
35455 PyThreadState* __tstate = wxPyBeginAllowThreads();
35456 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35457
35458 wxPyEndAllowThreads(__tstate);
35459 if (PyErr_Occurred()) SWIG_fail;
35460 }
35461 {
35462 resultobj = wxPyMake_wxObject(result, 0);
35463 }
35464 return resultobj;
35465 fail:
35466 return NULL;
35467 }
35468
35469
35470 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35471 PyObject *resultobj;
35472 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35473 wxString *arg2 = 0 ;
35474 int result;
35475 bool temp2 = false ;
35476 PyObject * obj0 = 0 ;
35477 PyObject * obj1 = 0 ;
35478 char *kwnames[] = {
35479 (char *) "self",(char *) "title", NULL
35480 };
35481
35482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35484 if (SWIG_arg_fail(1)) SWIG_fail;
35485 {
35486 arg2 = wxString_in_helper(obj1);
35487 if (arg2 == NULL) SWIG_fail;
35488 temp2 = true;
35489 }
35490 {
35491 PyThreadState* __tstate = wxPyBeginAllowThreads();
35492 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
35493
35494 wxPyEndAllowThreads(__tstate);
35495 if (PyErr_Occurred()) SWIG_fail;
35496 }
35497 {
35498 resultobj = SWIG_From_int((int)(result));
35499 }
35500 {
35501 if (temp2)
35502 delete arg2;
35503 }
35504 return resultobj;
35505 fail:
35506 {
35507 if (temp2)
35508 delete arg2;
35509 }
35510 return NULL;
35511 }
35512
35513
35514 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35515 PyObject *resultobj;
35516 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35517 int arg2 ;
35518 bool arg3 ;
35519 PyObject * obj0 = 0 ;
35520 PyObject * obj1 = 0 ;
35521 PyObject * obj2 = 0 ;
35522 char *kwnames[] = {
35523 (char *) "self",(char *) "id",(char *) "enable", NULL
35524 };
35525
35526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35528 if (SWIG_arg_fail(1)) SWIG_fail;
35529 {
35530 arg2 = (int)(SWIG_As_int(obj1));
35531 if (SWIG_arg_fail(2)) SWIG_fail;
35532 }
35533 {
35534 arg3 = (bool)(SWIG_As_bool(obj2));
35535 if (SWIG_arg_fail(3)) SWIG_fail;
35536 }
35537 {
35538 PyThreadState* __tstate = wxPyBeginAllowThreads();
35539 (arg1)->Enable(arg2,arg3);
35540
35541 wxPyEndAllowThreads(__tstate);
35542 if (PyErr_Occurred()) SWIG_fail;
35543 }
35544 Py_INCREF(Py_None); resultobj = Py_None;
35545 return resultobj;
35546 fail:
35547 return NULL;
35548 }
35549
35550
35551 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35552 PyObject *resultobj;
35553 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35554 int arg2 ;
35555 bool arg3 ;
35556 PyObject * obj0 = 0 ;
35557 PyObject * obj1 = 0 ;
35558 PyObject * obj2 = 0 ;
35559 char *kwnames[] = {
35560 (char *) "self",(char *) "id",(char *) "check", NULL
35561 };
35562
35563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35565 if (SWIG_arg_fail(1)) SWIG_fail;
35566 {
35567 arg2 = (int)(SWIG_As_int(obj1));
35568 if (SWIG_arg_fail(2)) SWIG_fail;
35569 }
35570 {
35571 arg3 = (bool)(SWIG_As_bool(obj2));
35572 if (SWIG_arg_fail(3)) SWIG_fail;
35573 }
35574 {
35575 PyThreadState* __tstate = wxPyBeginAllowThreads();
35576 (arg1)->Check(arg2,arg3);
35577
35578 wxPyEndAllowThreads(__tstate);
35579 if (PyErr_Occurred()) SWIG_fail;
35580 }
35581 Py_INCREF(Py_None); resultobj = Py_None;
35582 return resultobj;
35583 fail:
35584 return NULL;
35585 }
35586
35587
35588 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35589 PyObject *resultobj;
35590 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35591 int arg2 ;
35592 bool result;
35593 PyObject * obj0 = 0 ;
35594 PyObject * obj1 = 0 ;
35595 char *kwnames[] = {
35596 (char *) "self",(char *) "id", NULL
35597 };
35598
35599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35601 if (SWIG_arg_fail(1)) SWIG_fail;
35602 {
35603 arg2 = (int)(SWIG_As_int(obj1));
35604 if (SWIG_arg_fail(2)) SWIG_fail;
35605 }
35606 {
35607 PyThreadState* __tstate = wxPyBeginAllowThreads();
35608 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35609
35610 wxPyEndAllowThreads(__tstate);
35611 if (PyErr_Occurred()) SWIG_fail;
35612 }
35613 {
35614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35615 }
35616 return resultobj;
35617 fail:
35618 return NULL;
35619 }
35620
35621
35622 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35623 PyObject *resultobj;
35624 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35625 int arg2 ;
35626 bool result;
35627 PyObject * obj0 = 0 ;
35628 PyObject * obj1 = 0 ;
35629 char *kwnames[] = {
35630 (char *) "self",(char *) "id", NULL
35631 };
35632
35633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35635 if (SWIG_arg_fail(1)) SWIG_fail;
35636 {
35637 arg2 = (int)(SWIG_As_int(obj1));
35638 if (SWIG_arg_fail(2)) SWIG_fail;
35639 }
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35643
35644 wxPyEndAllowThreads(__tstate);
35645 if (PyErr_Occurred()) SWIG_fail;
35646 }
35647 {
35648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35649 }
35650 return resultobj;
35651 fail:
35652 return NULL;
35653 }
35654
35655
35656 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35657 PyObject *resultobj;
35658 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35659 int arg2 ;
35660 wxString *arg3 = 0 ;
35661 bool temp3 = false ;
35662 PyObject * obj0 = 0 ;
35663 PyObject * obj1 = 0 ;
35664 PyObject * obj2 = 0 ;
35665 char *kwnames[] = {
35666 (char *) "self",(char *) "id",(char *) "label", NULL
35667 };
35668
35669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35671 if (SWIG_arg_fail(1)) SWIG_fail;
35672 {
35673 arg2 = (int)(SWIG_As_int(obj1));
35674 if (SWIG_arg_fail(2)) SWIG_fail;
35675 }
35676 {
35677 arg3 = wxString_in_helper(obj2);
35678 if (arg3 == NULL) SWIG_fail;
35679 temp3 = true;
35680 }
35681 {
35682 PyThreadState* __tstate = wxPyBeginAllowThreads();
35683 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35684
35685 wxPyEndAllowThreads(__tstate);
35686 if (PyErr_Occurred()) SWIG_fail;
35687 }
35688 Py_INCREF(Py_None); resultobj = Py_None;
35689 {
35690 if (temp3)
35691 delete arg3;
35692 }
35693 return resultobj;
35694 fail:
35695 {
35696 if (temp3)
35697 delete arg3;
35698 }
35699 return NULL;
35700 }
35701
35702
35703 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35704 PyObject *resultobj;
35705 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35706 int arg2 ;
35707 wxString result;
35708 PyObject * obj0 = 0 ;
35709 PyObject * obj1 = 0 ;
35710 char *kwnames[] = {
35711 (char *) "self",(char *) "id", NULL
35712 };
35713
35714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35716 if (SWIG_arg_fail(1)) SWIG_fail;
35717 {
35718 arg2 = (int)(SWIG_As_int(obj1));
35719 if (SWIG_arg_fail(2)) SWIG_fail;
35720 }
35721 {
35722 PyThreadState* __tstate = wxPyBeginAllowThreads();
35723 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35724
35725 wxPyEndAllowThreads(__tstate);
35726 if (PyErr_Occurred()) SWIG_fail;
35727 }
35728 {
35729 #if wxUSE_UNICODE
35730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35731 #else
35732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35733 #endif
35734 }
35735 return resultobj;
35736 fail:
35737 return NULL;
35738 }
35739
35740
35741 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35742 PyObject *resultobj;
35743 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35744 int arg2 ;
35745 wxString *arg3 = 0 ;
35746 bool temp3 = false ;
35747 PyObject * obj0 = 0 ;
35748 PyObject * obj1 = 0 ;
35749 PyObject * obj2 = 0 ;
35750 char *kwnames[] = {
35751 (char *) "self",(char *) "id",(char *) "helpString", NULL
35752 };
35753
35754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35756 if (SWIG_arg_fail(1)) SWIG_fail;
35757 {
35758 arg2 = (int)(SWIG_As_int(obj1));
35759 if (SWIG_arg_fail(2)) SWIG_fail;
35760 }
35761 {
35762 arg3 = wxString_in_helper(obj2);
35763 if (arg3 == NULL) SWIG_fail;
35764 temp3 = true;
35765 }
35766 {
35767 PyThreadState* __tstate = wxPyBeginAllowThreads();
35768 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35769
35770 wxPyEndAllowThreads(__tstate);
35771 if (PyErr_Occurred()) SWIG_fail;
35772 }
35773 Py_INCREF(Py_None); resultobj = Py_None;
35774 {
35775 if (temp3)
35776 delete arg3;
35777 }
35778 return resultobj;
35779 fail:
35780 {
35781 if (temp3)
35782 delete arg3;
35783 }
35784 return NULL;
35785 }
35786
35787
35788 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35789 PyObject *resultobj;
35790 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35791 int arg2 ;
35792 wxString result;
35793 PyObject * obj0 = 0 ;
35794 PyObject * obj1 = 0 ;
35795 char *kwnames[] = {
35796 (char *) "self",(char *) "id", NULL
35797 };
35798
35799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35801 if (SWIG_arg_fail(1)) SWIG_fail;
35802 {
35803 arg2 = (int)(SWIG_As_int(obj1));
35804 if (SWIG_arg_fail(2)) SWIG_fail;
35805 }
35806 {
35807 PyThreadState* __tstate = wxPyBeginAllowThreads();
35808 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35809
35810 wxPyEndAllowThreads(__tstate);
35811 if (PyErr_Occurred()) SWIG_fail;
35812 }
35813 {
35814 #if wxUSE_UNICODE
35815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35816 #else
35817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35818 #endif
35819 }
35820 return resultobj;
35821 fail:
35822 return NULL;
35823 }
35824
35825
35826 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35827 PyObject *resultobj;
35828 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35829 wxFrame *result;
35830 PyObject * obj0 = 0 ;
35831 char *kwnames[] = {
35832 (char *) "self", NULL
35833 };
35834
35835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35837 if (SWIG_arg_fail(1)) SWIG_fail;
35838 {
35839 PyThreadState* __tstate = wxPyBeginAllowThreads();
35840 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35841
35842 wxPyEndAllowThreads(__tstate);
35843 if (PyErr_Occurred()) SWIG_fail;
35844 }
35845 {
35846 resultobj = wxPyMake_wxObject(result, 0);
35847 }
35848 return resultobj;
35849 fail:
35850 return NULL;
35851 }
35852
35853
35854 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35855 PyObject *resultobj;
35856 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35857 bool result;
35858 PyObject * obj0 = 0 ;
35859 char *kwnames[] = {
35860 (char *) "self", NULL
35861 };
35862
35863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35865 if (SWIG_arg_fail(1)) SWIG_fail;
35866 {
35867 PyThreadState* __tstate = wxPyBeginAllowThreads();
35868 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35869
35870 wxPyEndAllowThreads(__tstate);
35871 if (PyErr_Occurred()) SWIG_fail;
35872 }
35873 {
35874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35875 }
35876 return resultobj;
35877 fail:
35878 return NULL;
35879 }
35880
35881
35882 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35883 PyObject *resultobj;
35884 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35885 wxFrame *arg2 = (wxFrame *) 0 ;
35886 PyObject * obj0 = 0 ;
35887 PyObject * obj1 = 0 ;
35888 char *kwnames[] = {
35889 (char *) "self",(char *) "frame", NULL
35890 };
35891
35892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35894 if (SWIG_arg_fail(1)) SWIG_fail;
35895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35896 if (SWIG_arg_fail(2)) SWIG_fail;
35897 {
35898 PyThreadState* __tstate = wxPyBeginAllowThreads();
35899 (arg1)->Attach(arg2);
35900
35901 wxPyEndAllowThreads(__tstate);
35902 if (PyErr_Occurred()) SWIG_fail;
35903 }
35904 Py_INCREF(Py_None); resultobj = Py_None;
35905 return resultobj;
35906 fail:
35907 return NULL;
35908 }
35909
35910
35911 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35912 PyObject *resultobj;
35913 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35914 PyObject * obj0 = 0 ;
35915 char *kwnames[] = {
35916 (char *) "self", NULL
35917 };
35918
35919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35921 if (SWIG_arg_fail(1)) SWIG_fail;
35922 {
35923 PyThreadState* __tstate = wxPyBeginAllowThreads();
35924 (arg1)->Detach();
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 * MenuBar_swigregister(PyObject *, PyObject *args) {
35937 PyObject *obj;
35938 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35939 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35940 Py_INCREF(obj);
35941 return Py_BuildValue((char *)"");
35942 }
35943 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35944 PyObject *resultobj;
35945 wxMenu *arg1 = (wxMenu *) NULL ;
35946 int arg2 = (int) wxID_ANY ;
35947 wxString const &arg3_defvalue = wxPyEmptyString ;
35948 wxString *arg3 = (wxString *) &arg3_defvalue ;
35949 wxString const &arg4_defvalue = wxPyEmptyString ;
35950 wxString *arg4 = (wxString *) &arg4_defvalue ;
35951 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35952 wxMenu *arg6 = (wxMenu *) NULL ;
35953 wxMenuItem *result;
35954 bool temp3 = false ;
35955 bool temp4 = false ;
35956 PyObject * obj0 = 0 ;
35957 PyObject * obj1 = 0 ;
35958 PyObject * obj2 = 0 ;
35959 PyObject * obj3 = 0 ;
35960 PyObject * obj4 = 0 ;
35961 PyObject * obj5 = 0 ;
35962 char *kwnames[] = {
35963 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35964 };
35965
35966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35967 if (obj0) {
35968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35969 if (SWIG_arg_fail(1)) SWIG_fail;
35970 }
35971 if (obj1) {
35972 {
35973 arg2 = (int)(SWIG_As_int(obj1));
35974 if (SWIG_arg_fail(2)) SWIG_fail;
35975 }
35976 }
35977 if (obj2) {
35978 {
35979 arg3 = wxString_in_helper(obj2);
35980 if (arg3 == NULL) SWIG_fail;
35981 temp3 = true;
35982 }
35983 }
35984 if (obj3) {
35985 {
35986 arg4 = wxString_in_helper(obj3);
35987 if (arg4 == NULL) SWIG_fail;
35988 temp4 = true;
35989 }
35990 }
35991 if (obj4) {
35992 {
35993 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35994 if (SWIG_arg_fail(5)) SWIG_fail;
35995 }
35996 }
35997 if (obj5) {
35998 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35999 if (SWIG_arg_fail(6)) SWIG_fail;
36000 }
36001 {
36002 PyThreadState* __tstate = wxPyBeginAllowThreads();
36003 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36004
36005 wxPyEndAllowThreads(__tstate);
36006 if (PyErr_Occurred()) SWIG_fail;
36007 }
36008 {
36009 resultobj = wxPyMake_wxObject(result, 1);
36010 }
36011 {
36012 if (temp3)
36013 delete arg3;
36014 }
36015 {
36016 if (temp4)
36017 delete arg4;
36018 }
36019 return resultobj;
36020 fail:
36021 {
36022 if (temp3)
36023 delete arg3;
36024 }
36025 {
36026 if (temp4)
36027 delete arg4;
36028 }
36029 return NULL;
36030 }
36031
36032
36033 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36034 PyObject *resultobj;
36035 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36036 wxMenu *result;
36037 PyObject * obj0 = 0 ;
36038 char *kwnames[] = {
36039 (char *) "self", NULL
36040 };
36041
36042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36044 if (SWIG_arg_fail(1)) SWIG_fail;
36045 {
36046 PyThreadState* __tstate = wxPyBeginAllowThreads();
36047 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36048
36049 wxPyEndAllowThreads(__tstate);
36050 if (PyErr_Occurred()) SWIG_fail;
36051 }
36052 {
36053 resultobj = wxPyMake_wxObject(result, 0);
36054 }
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36062 PyObject *resultobj;
36063 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36064 wxMenu *arg2 = (wxMenu *) 0 ;
36065 PyObject * obj0 = 0 ;
36066 PyObject * obj1 = 0 ;
36067 char *kwnames[] = {
36068 (char *) "self",(char *) "menu", NULL
36069 };
36070
36071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36073 if (SWIG_arg_fail(1)) SWIG_fail;
36074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36075 if (SWIG_arg_fail(2)) SWIG_fail;
36076 {
36077 PyThreadState* __tstate = wxPyBeginAllowThreads();
36078 (arg1)->SetMenu(arg2);
36079
36080 wxPyEndAllowThreads(__tstate);
36081 if (PyErr_Occurred()) SWIG_fail;
36082 }
36083 Py_INCREF(Py_None); resultobj = Py_None;
36084 return resultobj;
36085 fail:
36086 return NULL;
36087 }
36088
36089
36090 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36091 PyObject *resultobj;
36092 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36093 int arg2 ;
36094 PyObject * obj0 = 0 ;
36095 PyObject * obj1 = 0 ;
36096 char *kwnames[] = {
36097 (char *) "self",(char *) "id", NULL
36098 };
36099
36100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36102 if (SWIG_arg_fail(1)) SWIG_fail;
36103 {
36104 arg2 = (int)(SWIG_As_int(obj1));
36105 if (SWIG_arg_fail(2)) SWIG_fail;
36106 }
36107 {
36108 PyThreadState* __tstate = wxPyBeginAllowThreads();
36109 (arg1)->SetId(arg2);
36110
36111 wxPyEndAllowThreads(__tstate);
36112 if (PyErr_Occurred()) SWIG_fail;
36113 }
36114 Py_INCREF(Py_None); resultobj = Py_None;
36115 return resultobj;
36116 fail:
36117 return NULL;
36118 }
36119
36120
36121 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36122 PyObject *resultobj;
36123 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36124 int result;
36125 PyObject * obj0 = 0 ;
36126 char *kwnames[] = {
36127 (char *) "self", NULL
36128 };
36129
36130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36132 if (SWIG_arg_fail(1)) SWIG_fail;
36133 {
36134 PyThreadState* __tstate = wxPyBeginAllowThreads();
36135 result = (int)((wxMenuItem const *)arg1)->GetId();
36136
36137 wxPyEndAllowThreads(__tstate);
36138 if (PyErr_Occurred()) SWIG_fail;
36139 }
36140 {
36141 resultobj = SWIG_From_int((int)(result));
36142 }
36143 return resultobj;
36144 fail:
36145 return NULL;
36146 }
36147
36148
36149 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36150 PyObject *resultobj;
36151 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36152 bool result;
36153 PyObject * obj0 = 0 ;
36154 char *kwnames[] = {
36155 (char *) "self", NULL
36156 };
36157
36158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36160 if (SWIG_arg_fail(1)) SWIG_fail;
36161 {
36162 PyThreadState* __tstate = wxPyBeginAllowThreads();
36163 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36164
36165 wxPyEndAllowThreads(__tstate);
36166 if (PyErr_Occurred()) SWIG_fail;
36167 }
36168 {
36169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36170 }
36171 return resultobj;
36172 fail:
36173 return NULL;
36174 }
36175
36176
36177 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36178 PyObject *resultobj;
36179 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36180 wxString *arg2 = 0 ;
36181 bool temp2 = false ;
36182 PyObject * obj0 = 0 ;
36183 PyObject * obj1 = 0 ;
36184 char *kwnames[] = {
36185 (char *) "self",(char *) "str", NULL
36186 };
36187
36188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36190 if (SWIG_arg_fail(1)) SWIG_fail;
36191 {
36192 arg2 = wxString_in_helper(obj1);
36193 if (arg2 == NULL) SWIG_fail;
36194 temp2 = true;
36195 }
36196 {
36197 PyThreadState* __tstate = wxPyBeginAllowThreads();
36198 (arg1)->SetText((wxString const &)*arg2);
36199
36200 wxPyEndAllowThreads(__tstate);
36201 if (PyErr_Occurred()) SWIG_fail;
36202 }
36203 Py_INCREF(Py_None); resultobj = Py_None;
36204 {
36205 if (temp2)
36206 delete arg2;
36207 }
36208 return resultobj;
36209 fail:
36210 {
36211 if (temp2)
36212 delete arg2;
36213 }
36214 return NULL;
36215 }
36216
36217
36218 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36219 PyObject *resultobj;
36220 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36221 wxString result;
36222 PyObject * obj0 = 0 ;
36223 char *kwnames[] = {
36224 (char *) "self", NULL
36225 };
36226
36227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36229 if (SWIG_arg_fail(1)) SWIG_fail;
36230 {
36231 PyThreadState* __tstate = wxPyBeginAllowThreads();
36232 result = ((wxMenuItem const *)arg1)->GetLabel();
36233
36234 wxPyEndAllowThreads(__tstate);
36235 if (PyErr_Occurred()) SWIG_fail;
36236 }
36237 {
36238 #if wxUSE_UNICODE
36239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36240 #else
36241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36242 #endif
36243 }
36244 return resultobj;
36245 fail:
36246 return NULL;
36247 }
36248
36249
36250 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36251 PyObject *resultobj;
36252 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36253 wxString *result;
36254 PyObject * obj0 = 0 ;
36255 char *kwnames[] = {
36256 (char *) "self", NULL
36257 };
36258
36259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36261 if (SWIG_arg_fail(1)) SWIG_fail;
36262 {
36263 PyThreadState* __tstate = wxPyBeginAllowThreads();
36264 {
36265 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36266 result = (wxString *) &_result_ref;
36267 }
36268
36269 wxPyEndAllowThreads(__tstate);
36270 if (PyErr_Occurred()) SWIG_fail;
36271 }
36272 {
36273 #if wxUSE_UNICODE
36274 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36275 #else
36276 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36277 #endif
36278 }
36279 return resultobj;
36280 fail:
36281 return NULL;
36282 }
36283
36284
36285 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36286 PyObject *resultobj;
36287 wxString *arg1 = 0 ;
36288 wxString result;
36289 bool temp1 = false ;
36290 PyObject * obj0 = 0 ;
36291 char *kwnames[] = {
36292 (char *) "text", NULL
36293 };
36294
36295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36296 {
36297 arg1 = wxString_in_helper(obj0);
36298 if (arg1 == NULL) SWIG_fail;
36299 temp1 = true;
36300 }
36301 {
36302 PyThreadState* __tstate = wxPyBeginAllowThreads();
36303 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36304
36305 wxPyEndAllowThreads(__tstate);
36306 if (PyErr_Occurred()) SWIG_fail;
36307 }
36308 {
36309 #if wxUSE_UNICODE
36310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36311 #else
36312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36313 #endif
36314 }
36315 {
36316 if (temp1)
36317 delete arg1;
36318 }
36319 return resultobj;
36320 fail:
36321 {
36322 if (temp1)
36323 delete arg1;
36324 }
36325 return NULL;
36326 }
36327
36328
36329 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36330 PyObject *resultobj;
36331 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36332 wxItemKind result;
36333 PyObject * obj0 = 0 ;
36334 char *kwnames[] = {
36335 (char *) "self", NULL
36336 };
36337
36338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36340 if (SWIG_arg_fail(1)) SWIG_fail;
36341 {
36342 PyThreadState* __tstate = wxPyBeginAllowThreads();
36343 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36344
36345 wxPyEndAllowThreads(__tstate);
36346 if (PyErr_Occurred()) SWIG_fail;
36347 }
36348 resultobj = SWIG_From_int((result));
36349 return resultobj;
36350 fail:
36351 return NULL;
36352 }
36353
36354
36355 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36356 PyObject *resultobj;
36357 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36358 wxItemKind arg2 ;
36359 PyObject * obj0 = 0 ;
36360 PyObject * obj1 = 0 ;
36361 char *kwnames[] = {
36362 (char *) "self",(char *) "kind", NULL
36363 };
36364
36365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36367 if (SWIG_arg_fail(1)) SWIG_fail;
36368 {
36369 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36370 if (SWIG_arg_fail(2)) SWIG_fail;
36371 }
36372 {
36373 PyThreadState* __tstate = wxPyBeginAllowThreads();
36374 (arg1)->SetKind((wxItemKind )arg2);
36375
36376 wxPyEndAllowThreads(__tstate);
36377 if (PyErr_Occurred()) SWIG_fail;
36378 }
36379 Py_INCREF(Py_None); resultobj = Py_None;
36380 return resultobj;
36381 fail:
36382 return NULL;
36383 }
36384
36385
36386 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36387 PyObject *resultobj;
36388 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36389 bool arg2 ;
36390 PyObject * obj0 = 0 ;
36391 PyObject * obj1 = 0 ;
36392 char *kwnames[] = {
36393 (char *) "self",(char *) "checkable", NULL
36394 };
36395
36396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36398 if (SWIG_arg_fail(1)) SWIG_fail;
36399 {
36400 arg2 = (bool)(SWIG_As_bool(obj1));
36401 if (SWIG_arg_fail(2)) SWIG_fail;
36402 }
36403 {
36404 PyThreadState* __tstate = wxPyBeginAllowThreads();
36405 (arg1)->SetCheckable(arg2);
36406
36407 wxPyEndAllowThreads(__tstate);
36408 if (PyErr_Occurred()) SWIG_fail;
36409 }
36410 Py_INCREF(Py_None); resultobj = Py_None;
36411 return resultobj;
36412 fail:
36413 return NULL;
36414 }
36415
36416
36417 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36418 PyObject *resultobj;
36419 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36420 bool result;
36421 PyObject * obj0 = 0 ;
36422 char *kwnames[] = {
36423 (char *) "self", NULL
36424 };
36425
36426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36428 if (SWIG_arg_fail(1)) SWIG_fail;
36429 {
36430 PyThreadState* __tstate = wxPyBeginAllowThreads();
36431 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36432
36433 wxPyEndAllowThreads(__tstate);
36434 if (PyErr_Occurred()) SWIG_fail;
36435 }
36436 {
36437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36438 }
36439 return resultobj;
36440 fail:
36441 return NULL;
36442 }
36443
36444
36445 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36446 PyObject *resultobj;
36447 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36448 bool result;
36449 PyObject * obj0 = 0 ;
36450 char *kwnames[] = {
36451 (char *) "self", NULL
36452 };
36453
36454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36456 if (SWIG_arg_fail(1)) SWIG_fail;
36457 {
36458 PyThreadState* __tstate = wxPyBeginAllowThreads();
36459 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36460
36461 wxPyEndAllowThreads(__tstate);
36462 if (PyErr_Occurred()) SWIG_fail;
36463 }
36464 {
36465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36466 }
36467 return resultobj;
36468 fail:
36469 return NULL;
36470 }
36471
36472
36473 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36474 PyObject *resultobj;
36475 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36476 wxMenu *arg2 = (wxMenu *) 0 ;
36477 PyObject * obj0 = 0 ;
36478 PyObject * obj1 = 0 ;
36479 char *kwnames[] = {
36480 (char *) "self",(char *) "menu", NULL
36481 };
36482
36483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36485 if (SWIG_arg_fail(1)) SWIG_fail;
36486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36487 if (SWIG_arg_fail(2)) SWIG_fail;
36488 {
36489 PyThreadState* __tstate = wxPyBeginAllowThreads();
36490 (arg1)->SetSubMenu(arg2);
36491
36492 wxPyEndAllowThreads(__tstate);
36493 if (PyErr_Occurred()) SWIG_fail;
36494 }
36495 Py_INCREF(Py_None); resultobj = Py_None;
36496 return resultobj;
36497 fail:
36498 return NULL;
36499 }
36500
36501
36502 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36503 PyObject *resultobj;
36504 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36505 wxMenu *result;
36506 PyObject * obj0 = 0 ;
36507 char *kwnames[] = {
36508 (char *) "self", NULL
36509 };
36510
36511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36513 if (SWIG_arg_fail(1)) SWIG_fail;
36514 {
36515 PyThreadState* __tstate = wxPyBeginAllowThreads();
36516 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36517
36518 wxPyEndAllowThreads(__tstate);
36519 if (PyErr_Occurred()) SWIG_fail;
36520 }
36521 {
36522 resultobj = wxPyMake_wxObject(result, 0);
36523 }
36524 return resultobj;
36525 fail:
36526 return NULL;
36527 }
36528
36529
36530 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36531 PyObject *resultobj;
36532 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36533 bool arg2 = (bool) true ;
36534 PyObject * obj0 = 0 ;
36535 PyObject * obj1 = 0 ;
36536 char *kwnames[] = {
36537 (char *) "self",(char *) "enable", NULL
36538 };
36539
36540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36542 if (SWIG_arg_fail(1)) SWIG_fail;
36543 if (obj1) {
36544 {
36545 arg2 = (bool)(SWIG_As_bool(obj1));
36546 if (SWIG_arg_fail(2)) SWIG_fail;
36547 }
36548 }
36549 {
36550 PyThreadState* __tstate = wxPyBeginAllowThreads();
36551 (arg1)->Enable(arg2);
36552
36553 wxPyEndAllowThreads(__tstate);
36554 if (PyErr_Occurred()) SWIG_fail;
36555 }
36556 Py_INCREF(Py_None); resultobj = Py_None;
36557 return resultobj;
36558 fail:
36559 return NULL;
36560 }
36561
36562
36563 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36564 PyObject *resultobj;
36565 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36566 bool result;
36567 PyObject * obj0 = 0 ;
36568 char *kwnames[] = {
36569 (char *) "self", NULL
36570 };
36571
36572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36574 if (SWIG_arg_fail(1)) SWIG_fail;
36575 {
36576 PyThreadState* __tstate = wxPyBeginAllowThreads();
36577 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36578
36579 wxPyEndAllowThreads(__tstate);
36580 if (PyErr_Occurred()) SWIG_fail;
36581 }
36582 {
36583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36584 }
36585 return resultobj;
36586 fail:
36587 return NULL;
36588 }
36589
36590
36591 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36592 PyObject *resultobj;
36593 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36594 bool arg2 = (bool) true ;
36595 PyObject * obj0 = 0 ;
36596 PyObject * obj1 = 0 ;
36597 char *kwnames[] = {
36598 (char *) "self",(char *) "check", NULL
36599 };
36600
36601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36603 if (SWIG_arg_fail(1)) SWIG_fail;
36604 if (obj1) {
36605 {
36606 arg2 = (bool)(SWIG_As_bool(obj1));
36607 if (SWIG_arg_fail(2)) SWIG_fail;
36608 }
36609 }
36610 {
36611 PyThreadState* __tstate = wxPyBeginAllowThreads();
36612 (arg1)->Check(arg2);
36613
36614 wxPyEndAllowThreads(__tstate);
36615 if (PyErr_Occurred()) SWIG_fail;
36616 }
36617 Py_INCREF(Py_None); resultobj = Py_None;
36618 return resultobj;
36619 fail:
36620 return NULL;
36621 }
36622
36623
36624 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36625 PyObject *resultobj;
36626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36627 bool result;
36628 PyObject * obj0 = 0 ;
36629 char *kwnames[] = {
36630 (char *) "self", NULL
36631 };
36632
36633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36635 if (SWIG_arg_fail(1)) SWIG_fail;
36636 {
36637 PyThreadState* __tstate = wxPyBeginAllowThreads();
36638 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36639
36640 wxPyEndAllowThreads(__tstate);
36641 if (PyErr_Occurred()) SWIG_fail;
36642 }
36643 {
36644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36645 }
36646 return resultobj;
36647 fail:
36648 return NULL;
36649 }
36650
36651
36652 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36653 PyObject *resultobj;
36654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36655 PyObject * obj0 = 0 ;
36656 char *kwnames[] = {
36657 (char *) "self", NULL
36658 };
36659
36660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36662 if (SWIG_arg_fail(1)) SWIG_fail;
36663 {
36664 PyThreadState* __tstate = wxPyBeginAllowThreads();
36665 (arg1)->Toggle();
36666
36667 wxPyEndAllowThreads(__tstate);
36668 if (PyErr_Occurred()) SWIG_fail;
36669 }
36670 Py_INCREF(Py_None); resultobj = Py_None;
36671 return resultobj;
36672 fail:
36673 return NULL;
36674 }
36675
36676
36677 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36678 PyObject *resultobj;
36679 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36680 wxString *arg2 = 0 ;
36681 bool temp2 = false ;
36682 PyObject * obj0 = 0 ;
36683 PyObject * obj1 = 0 ;
36684 char *kwnames[] = {
36685 (char *) "self",(char *) "str", NULL
36686 };
36687
36688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36690 if (SWIG_arg_fail(1)) SWIG_fail;
36691 {
36692 arg2 = wxString_in_helper(obj1);
36693 if (arg2 == NULL) SWIG_fail;
36694 temp2 = true;
36695 }
36696 {
36697 PyThreadState* __tstate = wxPyBeginAllowThreads();
36698 (arg1)->SetHelp((wxString const &)*arg2);
36699
36700 wxPyEndAllowThreads(__tstate);
36701 if (PyErr_Occurred()) SWIG_fail;
36702 }
36703 Py_INCREF(Py_None); resultobj = Py_None;
36704 {
36705 if (temp2)
36706 delete arg2;
36707 }
36708 return resultobj;
36709 fail:
36710 {
36711 if (temp2)
36712 delete arg2;
36713 }
36714 return NULL;
36715 }
36716
36717
36718 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36719 PyObject *resultobj;
36720 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36721 wxString *result;
36722 PyObject * obj0 = 0 ;
36723 char *kwnames[] = {
36724 (char *) "self", NULL
36725 };
36726
36727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36729 if (SWIG_arg_fail(1)) SWIG_fail;
36730 {
36731 PyThreadState* __tstate = wxPyBeginAllowThreads();
36732 {
36733 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36734 result = (wxString *) &_result_ref;
36735 }
36736
36737 wxPyEndAllowThreads(__tstate);
36738 if (PyErr_Occurred()) SWIG_fail;
36739 }
36740 {
36741 #if wxUSE_UNICODE
36742 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36743 #else
36744 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36745 #endif
36746 }
36747 return resultobj;
36748 fail:
36749 return NULL;
36750 }
36751
36752
36753 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36754 PyObject *resultobj;
36755 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36756 wxAcceleratorEntry *result;
36757 PyObject * obj0 = 0 ;
36758 char *kwnames[] = {
36759 (char *) "self", NULL
36760 };
36761
36762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36764 if (SWIG_arg_fail(1)) SWIG_fail;
36765 {
36766 PyThreadState* __tstate = wxPyBeginAllowThreads();
36767 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36768
36769 wxPyEndAllowThreads(__tstate);
36770 if (PyErr_Occurred()) SWIG_fail;
36771 }
36772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36773 return resultobj;
36774 fail:
36775 return NULL;
36776 }
36777
36778
36779 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36780 PyObject *resultobj;
36781 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36782 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36783 PyObject * obj0 = 0 ;
36784 PyObject * obj1 = 0 ;
36785 char *kwnames[] = {
36786 (char *) "self",(char *) "accel", NULL
36787 };
36788
36789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36791 if (SWIG_arg_fail(1)) SWIG_fail;
36792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36793 if (SWIG_arg_fail(2)) SWIG_fail;
36794 {
36795 PyThreadState* __tstate = wxPyBeginAllowThreads();
36796 (arg1)->SetAccel(arg2);
36797
36798 wxPyEndAllowThreads(__tstate);
36799 if (PyErr_Occurred()) SWIG_fail;
36800 }
36801 Py_INCREF(Py_None); resultobj = Py_None;
36802 return resultobj;
36803 fail:
36804 return NULL;
36805 }
36806
36807
36808 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36809 PyObject *resultobj;
36810 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36811 wxFont *arg2 = 0 ;
36812 PyObject * obj0 = 0 ;
36813 PyObject * obj1 = 0 ;
36814 char *kwnames[] = {
36815 (char *) "self",(char *) "font", NULL
36816 };
36817
36818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36820 if (SWIG_arg_fail(1)) SWIG_fail;
36821 {
36822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36823 if (SWIG_arg_fail(2)) SWIG_fail;
36824 if (arg2 == NULL) {
36825 SWIG_null_ref("wxFont");
36826 }
36827 if (SWIG_arg_fail(2)) SWIG_fail;
36828 }
36829 {
36830 PyThreadState* __tstate = wxPyBeginAllowThreads();
36831 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36832
36833 wxPyEndAllowThreads(__tstate);
36834 if (PyErr_Occurred()) SWIG_fail;
36835 }
36836 Py_INCREF(Py_None); resultobj = Py_None;
36837 return resultobj;
36838 fail:
36839 return NULL;
36840 }
36841
36842
36843 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36844 PyObject *resultobj;
36845 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36846 wxFont result;
36847 PyObject * obj0 = 0 ;
36848 char *kwnames[] = {
36849 (char *) "self", NULL
36850 };
36851
36852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36854 if (SWIG_arg_fail(1)) SWIG_fail;
36855 {
36856 PyThreadState* __tstate = wxPyBeginAllowThreads();
36857 result = wxMenuItem_GetFont(arg1);
36858
36859 wxPyEndAllowThreads(__tstate);
36860 if (PyErr_Occurred()) SWIG_fail;
36861 }
36862 {
36863 wxFont * resultptr;
36864 resultptr = new wxFont((wxFont &)(result));
36865 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36866 }
36867 return resultobj;
36868 fail:
36869 return NULL;
36870 }
36871
36872
36873 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36874 PyObject *resultobj;
36875 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36876 wxColour *arg2 = 0 ;
36877 wxColour temp2 ;
36878 PyObject * obj0 = 0 ;
36879 PyObject * obj1 = 0 ;
36880 char *kwnames[] = {
36881 (char *) "self",(char *) "colText", NULL
36882 };
36883
36884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36886 if (SWIG_arg_fail(1)) SWIG_fail;
36887 {
36888 arg2 = &temp2;
36889 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36890 }
36891 {
36892 PyThreadState* __tstate = wxPyBeginAllowThreads();
36893 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36894
36895 wxPyEndAllowThreads(__tstate);
36896 if (PyErr_Occurred()) SWIG_fail;
36897 }
36898 Py_INCREF(Py_None); resultobj = Py_None;
36899 return resultobj;
36900 fail:
36901 return NULL;
36902 }
36903
36904
36905 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36906 PyObject *resultobj;
36907 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36908 wxColour result;
36909 PyObject * obj0 = 0 ;
36910 char *kwnames[] = {
36911 (char *) "self", NULL
36912 };
36913
36914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36916 if (SWIG_arg_fail(1)) SWIG_fail;
36917 {
36918 PyThreadState* __tstate = wxPyBeginAllowThreads();
36919 result = wxMenuItem_GetTextColour(arg1);
36920
36921 wxPyEndAllowThreads(__tstate);
36922 if (PyErr_Occurred()) SWIG_fail;
36923 }
36924 {
36925 wxColour * resultptr;
36926 resultptr = new wxColour((wxColour &)(result));
36927 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36928 }
36929 return resultobj;
36930 fail:
36931 return NULL;
36932 }
36933
36934
36935 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36936 PyObject *resultobj;
36937 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36938 wxColour *arg2 = 0 ;
36939 wxColour temp2 ;
36940 PyObject * obj0 = 0 ;
36941 PyObject * obj1 = 0 ;
36942 char *kwnames[] = {
36943 (char *) "self",(char *) "colBack", NULL
36944 };
36945
36946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36948 if (SWIG_arg_fail(1)) SWIG_fail;
36949 {
36950 arg2 = &temp2;
36951 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36952 }
36953 {
36954 PyThreadState* __tstate = wxPyBeginAllowThreads();
36955 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36956
36957 wxPyEndAllowThreads(__tstate);
36958 if (PyErr_Occurred()) SWIG_fail;
36959 }
36960 Py_INCREF(Py_None); resultobj = Py_None;
36961 return resultobj;
36962 fail:
36963 return NULL;
36964 }
36965
36966
36967 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36968 PyObject *resultobj;
36969 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36970 wxColour result;
36971 PyObject * obj0 = 0 ;
36972 char *kwnames[] = {
36973 (char *) "self", NULL
36974 };
36975
36976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36978 if (SWIG_arg_fail(1)) SWIG_fail;
36979 {
36980 PyThreadState* __tstate = wxPyBeginAllowThreads();
36981 result = wxMenuItem_GetBackgroundColour(arg1);
36982
36983 wxPyEndAllowThreads(__tstate);
36984 if (PyErr_Occurred()) SWIG_fail;
36985 }
36986 {
36987 wxColour * resultptr;
36988 resultptr = new wxColour((wxColour &)(result));
36989 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36990 }
36991 return resultobj;
36992 fail:
36993 return NULL;
36994 }
36995
36996
36997 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36998 PyObject *resultobj;
36999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37000 wxBitmap *arg2 = 0 ;
37001 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37002 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37003 PyObject * obj0 = 0 ;
37004 PyObject * obj1 = 0 ;
37005 PyObject * obj2 = 0 ;
37006 char *kwnames[] = {
37007 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37008 };
37009
37010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37012 if (SWIG_arg_fail(1)) SWIG_fail;
37013 {
37014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37015 if (SWIG_arg_fail(2)) SWIG_fail;
37016 if (arg2 == NULL) {
37017 SWIG_null_ref("wxBitmap");
37018 }
37019 if (SWIG_arg_fail(2)) SWIG_fail;
37020 }
37021 if (obj2) {
37022 {
37023 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37024 if (SWIG_arg_fail(3)) SWIG_fail;
37025 if (arg3 == NULL) {
37026 SWIG_null_ref("wxBitmap");
37027 }
37028 if (SWIG_arg_fail(3)) SWIG_fail;
37029 }
37030 }
37031 {
37032 PyThreadState* __tstate = wxPyBeginAllowThreads();
37033 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37034
37035 wxPyEndAllowThreads(__tstate);
37036 if (PyErr_Occurred()) SWIG_fail;
37037 }
37038 Py_INCREF(Py_None); resultobj = Py_None;
37039 return resultobj;
37040 fail:
37041 return NULL;
37042 }
37043
37044
37045 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37046 PyObject *resultobj;
37047 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37048 wxBitmap *arg2 = 0 ;
37049 PyObject * obj0 = 0 ;
37050 PyObject * obj1 = 0 ;
37051 char *kwnames[] = {
37052 (char *) "self",(char *) "bmpDisabled", NULL
37053 };
37054
37055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37057 if (SWIG_arg_fail(1)) SWIG_fail;
37058 {
37059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37060 if (SWIG_arg_fail(2)) SWIG_fail;
37061 if (arg2 == NULL) {
37062 SWIG_null_ref("wxBitmap");
37063 }
37064 if (SWIG_arg_fail(2)) SWIG_fail;
37065 }
37066 {
37067 PyThreadState* __tstate = wxPyBeginAllowThreads();
37068 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37069
37070 wxPyEndAllowThreads(__tstate);
37071 if (PyErr_Occurred()) SWIG_fail;
37072 }
37073 Py_INCREF(Py_None); resultobj = Py_None;
37074 return resultobj;
37075 fail:
37076 return NULL;
37077 }
37078
37079
37080 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37081 PyObject *resultobj;
37082 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37083 wxBitmap *result;
37084 PyObject * obj0 = 0 ;
37085 char *kwnames[] = {
37086 (char *) "self", NULL
37087 };
37088
37089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37091 if (SWIG_arg_fail(1)) SWIG_fail;
37092 {
37093 PyThreadState* __tstate = wxPyBeginAllowThreads();
37094 {
37095 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37096 result = (wxBitmap *) &_result_ref;
37097 }
37098
37099 wxPyEndAllowThreads(__tstate);
37100 if (PyErr_Occurred()) SWIG_fail;
37101 }
37102 {
37103 wxBitmap* resultptr = new wxBitmap(*result);
37104 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37105 }
37106 return resultobj;
37107 fail:
37108 return NULL;
37109 }
37110
37111
37112 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37113 PyObject *resultobj;
37114 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37115 int arg2 ;
37116 PyObject * obj0 = 0 ;
37117 PyObject * obj1 = 0 ;
37118 char *kwnames[] = {
37119 (char *) "self",(char *) "nWidth", NULL
37120 };
37121
37122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37124 if (SWIG_arg_fail(1)) SWIG_fail;
37125 {
37126 arg2 = (int)(SWIG_As_int(obj1));
37127 if (SWIG_arg_fail(2)) SWIG_fail;
37128 }
37129 {
37130 PyThreadState* __tstate = wxPyBeginAllowThreads();
37131 wxMenuItem_SetMarginWidth(arg1,arg2);
37132
37133 wxPyEndAllowThreads(__tstate);
37134 if (PyErr_Occurred()) SWIG_fail;
37135 }
37136 Py_INCREF(Py_None); resultobj = Py_None;
37137 return resultobj;
37138 fail:
37139 return NULL;
37140 }
37141
37142
37143 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37144 PyObject *resultobj;
37145 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37146 int result;
37147 PyObject * obj0 = 0 ;
37148 char *kwnames[] = {
37149 (char *) "self", NULL
37150 };
37151
37152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37154 if (SWIG_arg_fail(1)) SWIG_fail;
37155 {
37156 PyThreadState* __tstate = wxPyBeginAllowThreads();
37157 result = (int)wxMenuItem_GetMarginWidth(arg1);
37158
37159 wxPyEndAllowThreads(__tstate);
37160 if (PyErr_Occurred()) SWIG_fail;
37161 }
37162 {
37163 resultobj = SWIG_From_int((int)(result));
37164 }
37165 return resultobj;
37166 fail:
37167 return NULL;
37168 }
37169
37170
37171 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37172 PyObject *resultobj;
37173 int result;
37174 char *kwnames[] = {
37175 NULL
37176 };
37177
37178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37179 {
37180 PyThreadState* __tstate = wxPyBeginAllowThreads();
37181 result = (int)MenuItem_GetDefaultMarginWidth();
37182
37183 wxPyEndAllowThreads(__tstate);
37184 if (PyErr_Occurred()) SWIG_fail;
37185 }
37186 {
37187 resultobj = SWIG_From_int((int)(result));
37188 }
37189 return resultobj;
37190 fail:
37191 return NULL;
37192 }
37193
37194
37195 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37196 PyObject *resultobj;
37197 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37198 bool result;
37199 PyObject * obj0 = 0 ;
37200 char *kwnames[] = {
37201 (char *) "self", NULL
37202 };
37203
37204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37206 if (SWIG_arg_fail(1)) SWIG_fail;
37207 {
37208 PyThreadState* __tstate = wxPyBeginAllowThreads();
37209 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37210
37211 wxPyEndAllowThreads(__tstate);
37212 if (PyErr_Occurred()) SWIG_fail;
37213 }
37214 {
37215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37216 }
37217 return resultobj;
37218 fail:
37219 return NULL;
37220 }
37221
37222
37223 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37224 PyObject *resultobj;
37225 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37226 bool arg2 = (bool) true ;
37227 PyObject * obj0 = 0 ;
37228 PyObject * obj1 = 0 ;
37229 char *kwnames[] = {
37230 (char *) "self",(char *) "ownerDrawn", NULL
37231 };
37232
37233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37235 if (SWIG_arg_fail(1)) SWIG_fail;
37236 if (obj1) {
37237 {
37238 arg2 = (bool)(SWIG_As_bool(obj1));
37239 if (SWIG_arg_fail(2)) SWIG_fail;
37240 }
37241 }
37242 {
37243 PyThreadState* __tstate = wxPyBeginAllowThreads();
37244 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37245
37246 wxPyEndAllowThreads(__tstate);
37247 if (PyErr_Occurred()) SWIG_fail;
37248 }
37249 Py_INCREF(Py_None); resultobj = Py_None;
37250 return resultobj;
37251 fail:
37252 return NULL;
37253 }
37254
37255
37256 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37257 PyObject *resultobj;
37258 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37259 PyObject * obj0 = 0 ;
37260 char *kwnames[] = {
37261 (char *) "self", NULL
37262 };
37263
37264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37266 if (SWIG_arg_fail(1)) SWIG_fail;
37267 {
37268 PyThreadState* __tstate = wxPyBeginAllowThreads();
37269 wxMenuItem_ResetOwnerDrawn(arg1);
37270
37271 wxPyEndAllowThreads(__tstate);
37272 if (PyErr_Occurred()) SWIG_fail;
37273 }
37274 Py_INCREF(Py_None); resultobj = Py_None;
37275 return resultobj;
37276 fail:
37277 return NULL;
37278 }
37279
37280
37281 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37282 PyObject *resultobj;
37283 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37284 wxBitmap *arg2 = 0 ;
37285 PyObject * obj0 = 0 ;
37286 PyObject * obj1 = 0 ;
37287 char *kwnames[] = {
37288 (char *) "self",(char *) "bitmap", NULL
37289 };
37290
37291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37293 if (SWIG_arg_fail(1)) SWIG_fail;
37294 {
37295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37296 if (SWIG_arg_fail(2)) SWIG_fail;
37297 if (arg2 == NULL) {
37298 SWIG_null_ref("wxBitmap");
37299 }
37300 if (SWIG_arg_fail(2)) SWIG_fail;
37301 }
37302 {
37303 PyThreadState* __tstate = wxPyBeginAllowThreads();
37304 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37305
37306 wxPyEndAllowThreads(__tstate);
37307 if (PyErr_Occurred()) SWIG_fail;
37308 }
37309 Py_INCREF(Py_None); resultobj = Py_None;
37310 return resultobj;
37311 fail:
37312 return NULL;
37313 }
37314
37315
37316 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37317 PyObject *resultobj;
37318 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37319 wxBitmap *result;
37320 PyObject * obj0 = 0 ;
37321 char *kwnames[] = {
37322 (char *) "self", NULL
37323 };
37324
37325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37327 if (SWIG_arg_fail(1)) SWIG_fail;
37328 {
37329 PyThreadState* __tstate = wxPyBeginAllowThreads();
37330 {
37331 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37332 result = (wxBitmap *) &_result_ref;
37333 }
37334
37335 wxPyEndAllowThreads(__tstate);
37336 if (PyErr_Occurred()) SWIG_fail;
37337 }
37338 {
37339 wxBitmap* resultptr = new wxBitmap(*result);
37340 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37341 }
37342 return resultobj;
37343 fail:
37344 return NULL;
37345 }
37346
37347
37348 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37349 PyObject *obj;
37350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37351 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37352 Py_INCREF(obj);
37353 return Py_BuildValue((char *)"");
37354 }
37355 static int _wrap_ControlNameStr_set(PyObject *) {
37356 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37357 return 1;
37358 }
37359
37360
37361 static PyObject *_wrap_ControlNameStr_get(void) {
37362 PyObject *pyobj;
37363
37364 {
37365 #if wxUSE_UNICODE
37366 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37367 #else
37368 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37369 #endif
37370 }
37371 return pyobj;
37372 }
37373
37374
37375 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37376 PyObject *resultobj;
37377 wxWindow *arg1 = (wxWindow *) 0 ;
37378 int arg2 = (int) -1 ;
37379 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37380 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37381 wxSize const &arg4_defvalue = wxDefaultSize ;
37382 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37383 long arg5 = (long) 0 ;
37384 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37385 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37386 wxString const &arg7_defvalue = wxPyControlNameStr ;
37387 wxString *arg7 = (wxString *) &arg7_defvalue ;
37388 wxControl *result;
37389 wxPoint temp3 ;
37390 wxSize temp4 ;
37391 bool temp7 = false ;
37392 PyObject * obj0 = 0 ;
37393 PyObject * obj1 = 0 ;
37394 PyObject * obj2 = 0 ;
37395 PyObject * obj3 = 0 ;
37396 PyObject * obj4 = 0 ;
37397 PyObject * obj5 = 0 ;
37398 PyObject * obj6 = 0 ;
37399 char *kwnames[] = {
37400 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37401 };
37402
37403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37405 if (SWIG_arg_fail(1)) SWIG_fail;
37406 if (obj1) {
37407 {
37408 arg2 = (int)(SWIG_As_int(obj1));
37409 if (SWIG_arg_fail(2)) SWIG_fail;
37410 }
37411 }
37412 if (obj2) {
37413 {
37414 arg3 = &temp3;
37415 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37416 }
37417 }
37418 if (obj3) {
37419 {
37420 arg4 = &temp4;
37421 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37422 }
37423 }
37424 if (obj4) {
37425 {
37426 arg5 = (long)(SWIG_As_long(obj4));
37427 if (SWIG_arg_fail(5)) SWIG_fail;
37428 }
37429 }
37430 if (obj5) {
37431 {
37432 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37433 if (SWIG_arg_fail(6)) SWIG_fail;
37434 if (arg6 == NULL) {
37435 SWIG_null_ref("wxValidator");
37436 }
37437 if (SWIG_arg_fail(6)) SWIG_fail;
37438 }
37439 }
37440 if (obj6) {
37441 {
37442 arg7 = wxString_in_helper(obj6);
37443 if (arg7 == NULL) SWIG_fail;
37444 temp7 = true;
37445 }
37446 }
37447 {
37448 if (!wxPyCheckForApp()) SWIG_fail;
37449 PyThreadState* __tstate = wxPyBeginAllowThreads();
37450 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37451
37452 wxPyEndAllowThreads(__tstate);
37453 if (PyErr_Occurred()) SWIG_fail;
37454 }
37455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37456 {
37457 if (temp7)
37458 delete arg7;
37459 }
37460 return resultobj;
37461 fail:
37462 {
37463 if (temp7)
37464 delete arg7;
37465 }
37466 return NULL;
37467 }
37468
37469
37470 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37471 PyObject *resultobj;
37472 wxControl *result;
37473 char *kwnames[] = {
37474 NULL
37475 };
37476
37477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37478 {
37479 if (!wxPyCheckForApp()) SWIG_fail;
37480 PyThreadState* __tstate = wxPyBeginAllowThreads();
37481 result = (wxControl *)new wxControl();
37482
37483 wxPyEndAllowThreads(__tstate);
37484 if (PyErr_Occurred()) SWIG_fail;
37485 }
37486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37487 return resultobj;
37488 fail:
37489 return NULL;
37490 }
37491
37492
37493 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37494 PyObject *resultobj;
37495 wxControl *arg1 = (wxControl *) 0 ;
37496 wxWindow *arg2 = (wxWindow *) 0 ;
37497 int arg3 = (int) -1 ;
37498 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37499 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37500 wxSize const &arg5_defvalue = wxDefaultSize ;
37501 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37502 long arg6 = (long) 0 ;
37503 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37504 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37505 wxString const &arg8_defvalue = wxPyControlNameStr ;
37506 wxString *arg8 = (wxString *) &arg8_defvalue ;
37507 bool result;
37508 wxPoint temp4 ;
37509 wxSize temp5 ;
37510 bool temp8 = false ;
37511 PyObject * obj0 = 0 ;
37512 PyObject * obj1 = 0 ;
37513 PyObject * obj2 = 0 ;
37514 PyObject * obj3 = 0 ;
37515 PyObject * obj4 = 0 ;
37516 PyObject * obj5 = 0 ;
37517 PyObject * obj6 = 0 ;
37518 PyObject * obj7 = 0 ;
37519 char *kwnames[] = {
37520 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37521 };
37522
37523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37525 if (SWIG_arg_fail(1)) SWIG_fail;
37526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37527 if (SWIG_arg_fail(2)) SWIG_fail;
37528 if (obj2) {
37529 {
37530 arg3 = (int)(SWIG_As_int(obj2));
37531 if (SWIG_arg_fail(3)) SWIG_fail;
37532 }
37533 }
37534 if (obj3) {
37535 {
37536 arg4 = &temp4;
37537 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37538 }
37539 }
37540 if (obj4) {
37541 {
37542 arg5 = &temp5;
37543 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37544 }
37545 }
37546 if (obj5) {
37547 {
37548 arg6 = (long)(SWIG_As_long(obj5));
37549 if (SWIG_arg_fail(6)) SWIG_fail;
37550 }
37551 }
37552 if (obj6) {
37553 {
37554 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37555 if (SWIG_arg_fail(7)) SWIG_fail;
37556 if (arg7 == NULL) {
37557 SWIG_null_ref("wxValidator");
37558 }
37559 if (SWIG_arg_fail(7)) SWIG_fail;
37560 }
37561 }
37562 if (obj7) {
37563 {
37564 arg8 = wxString_in_helper(obj7);
37565 if (arg8 == NULL) SWIG_fail;
37566 temp8 = true;
37567 }
37568 }
37569 {
37570 PyThreadState* __tstate = wxPyBeginAllowThreads();
37571 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37572
37573 wxPyEndAllowThreads(__tstate);
37574 if (PyErr_Occurred()) SWIG_fail;
37575 }
37576 {
37577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37578 }
37579 {
37580 if (temp8)
37581 delete arg8;
37582 }
37583 return resultobj;
37584 fail:
37585 {
37586 if (temp8)
37587 delete arg8;
37588 }
37589 return NULL;
37590 }
37591
37592
37593 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37594 PyObject *resultobj;
37595 wxControl *arg1 = (wxControl *) 0 ;
37596 wxCommandEvent *arg2 = 0 ;
37597 PyObject * obj0 = 0 ;
37598 PyObject * obj1 = 0 ;
37599 char *kwnames[] = {
37600 (char *) "self",(char *) "event", NULL
37601 };
37602
37603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37605 if (SWIG_arg_fail(1)) SWIG_fail;
37606 {
37607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37608 if (SWIG_arg_fail(2)) SWIG_fail;
37609 if (arg2 == NULL) {
37610 SWIG_null_ref("wxCommandEvent");
37611 }
37612 if (SWIG_arg_fail(2)) SWIG_fail;
37613 }
37614 {
37615 PyThreadState* __tstate = wxPyBeginAllowThreads();
37616 (arg1)->Command(*arg2);
37617
37618 wxPyEndAllowThreads(__tstate);
37619 if (PyErr_Occurred()) SWIG_fail;
37620 }
37621 Py_INCREF(Py_None); resultobj = Py_None;
37622 return resultobj;
37623 fail:
37624 return NULL;
37625 }
37626
37627
37628 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37629 PyObject *resultobj;
37630 wxControl *arg1 = (wxControl *) 0 ;
37631 wxString result;
37632 PyObject * obj0 = 0 ;
37633 char *kwnames[] = {
37634 (char *) "self", NULL
37635 };
37636
37637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37639 if (SWIG_arg_fail(1)) SWIG_fail;
37640 {
37641 PyThreadState* __tstate = wxPyBeginAllowThreads();
37642 result = (arg1)->GetLabel();
37643
37644 wxPyEndAllowThreads(__tstate);
37645 if (PyErr_Occurred()) SWIG_fail;
37646 }
37647 {
37648 #if wxUSE_UNICODE
37649 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37650 #else
37651 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37652 #endif
37653 }
37654 return resultobj;
37655 fail:
37656 return NULL;
37657 }
37658
37659
37660 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37661 PyObject *resultobj;
37662 wxControl *arg1 = (wxControl *) 0 ;
37663 wxString *arg2 = 0 ;
37664 bool temp2 = false ;
37665 PyObject * obj0 = 0 ;
37666 PyObject * obj1 = 0 ;
37667 char *kwnames[] = {
37668 (char *) "self",(char *) "label", NULL
37669 };
37670
37671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37673 if (SWIG_arg_fail(1)) SWIG_fail;
37674 {
37675 arg2 = wxString_in_helper(obj1);
37676 if (arg2 == NULL) SWIG_fail;
37677 temp2 = true;
37678 }
37679 {
37680 PyThreadState* __tstate = wxPyBeginAllowThreads();
37681 (arg1)->SetLabel((wxString const &)*arg2);
37682
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 Py_INCREF(Py_None); resultobj = Py_None;
37687 {
37688 if (temp2)
37689 delete arg2;
37690 }
37691 return resultobj;
37692 fail:
37693 {
37694 if (temp2)
37695 delete arg2;
37696 }
37697 return NULL;
37698 }
37699
37700
37701 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37702 PyObject *resultobj;
37703 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37704 wxVisualAttributes result;
37705 PyObject * obj0 = 0 ;
37706 char *kwnames[] = {
37707 (char *) "variant", NULL
37708 };
37709
37710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37711 if (obj0) {
37712 {
37713 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37714 if (SWIG_arg_fail(1)) SWIG_fail;
37715 }
37716 }
37717 {
37718 if (!wxPyCheckForApp()) SWIG_fail;
37719 PyThreadState* __tstate = wxPyBeginAllowThreads();
37720 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37721
37722 wxPyEndAllowThreads(__tstate);
37723 if (PyErr_Occurred()) SWIG_fail;
37724 }
37725 {
37726 wxVisualAttributes * resultptr;
37727 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37728 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37729 }
37730 return resultobj;
37731 fail:
37732 return NULL;
37733 }
37734
37735
37736 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37737 PyObject *obj;
37738 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37739 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37740 Py_INCREF(obj);
37741 return Py_BuildValue((char *)"");
37742 }
37743 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37744 PyObject *resultobj;
37745 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37746 wxString *arg2 = 0 ;
37747 PyObject *arg3 = (PyObject *) NULL ;
37748 int result;
37749 bool temp2 = false ;
37750 PyObject * obj0 = 0 ;
37751 PyObject * obj1 = 0 ;
37752 PyObject * obj2 = 0 ;
37753 char *kwnames[] = {
37754 (char *) "self",(char *) "item",(char *) "clientData", NULL
37755 };
37756
37757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37759 if (SWIG_arg_fail(1)) SWIG_fail;
37760 {
37761 arg2 = wxString_in_helper(obj1);
37762 if (arg2 == NULL) SWIG_fail;
37763 temp2 = true;
37764 }
37765 if (obj2) {
37766 arg3 = obj2;
37767 }
37768 {
37769 PyThreadState* __tstate = wxPyBeginAllowThreads();
37770 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37771
37772 wxPyEndAllowThreads(__tstate);
37773 if (PyErr_Occurred()) SWIG_fail;
37774 }
37775 {
37776 resultobj = SWIG_From_int((int)(result));
37777 }
37778 {
37779 if (temp2)
37780 delete arg2;
37781 }
37782 return resultobj;
37783 fail:
37784 {
37785 if (temp2)
37786 delete arg2;
37787 }
37788 return NULL;
37789 }
37790
37791
37792 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37793 PyObject *resultobj;
37794 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37795 wxArrayString *arg2 = 0 ;
37796 bool temp2 = false ;
37797 PyObject * obj0 = 0 ;
37798 PyObject * obj1 = 0 ;
37799 char *kwnames[] = {
37800 (char *) "self",(char *) "strings", NULL
37801 };
37802
37803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37805 if (SWIG_arg_fail(1)) SWIG_fail;
37806 {
37807 if (! PySequence_Check(obj1)) {
37808 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37809 SWIG_fail;
37810 }
37811 arg2 = new wxArrayString;
37812 temp2 = true;
37813 int i, len=PySequence_Length(obj1);
37814 for (i=0; i<len; i++) {
37815 PyObject* item = PySequence_GetItem(obj1, i);
37816 #if wxUSE_UNICODE
37817 PyObject* str = PyObject_Unicode(item);
37818 #else
37819 PyObject* str = PyObject_Str(item);
37820 #endif
37821 if (PyErr_Occurred()) SWIG_fail;
37822 arg2->Add(Py2wxString(str));
37823 Py_DECREF(item);
37824 Py_DECREF(str);
37825 }
37826 }
37827 {
37828 PyThreadState* __tstate = wxPyBeginAllowThreads();
37829 (arg1)->Append((wxArrayString const &)*arg2);
37830
37831 wxPyEndAllowThreads(__tstate);
37832 if (PyErr_Occurred()) SWIG_fail;
37833 }
37834 Py_INCREF(Py_None); resultobj = Py_None;
37835 {
37836 if (temp2) delete arg2;
37837 }
37838 return resultobj;
37839 fail:
37840 {
37841 if (temp2) delete arg2;
37842 }
37843 return NULL;
37844 }
37845
37846
37847 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37848 PyObject *resultobj;
37849 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37850 wxString *arg2 = 0 ;
37851 int arg3 ;
37852 PyObject *arg4 = (PyObject *) NULL ;
37853 int result;
37854 bool temp2 = false ;
37855 PyObject * obj0 = 0 ;
37856 PyObject * obj1 = 0 ;
37857 PyObject * obj2 = 0 ;
37858 PyObject * obj3 = 0 ;
37859 char *kwnames[] = {
37860 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37861 };
37862
37863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37865 if (SWIG_arg_fail(1)) SWIG_fail;
37866 {
37867 arg2 = wxString_in_helper(obj1);
37868 if (arg2 == NULL) SWIG_fail;
37869 temp2 = true;
37870 }
37871 {
37872 arg3 = (int)(SWIG_As_int(obj2));
37873 if (SWIG_arg_fail(3)) SWIG_fail;
37874 }
37875 if (obj3) {
37876 arg4 = obj3;
37877 }
37878 {
37879 PyThreadState* __tstate = wxPyBeginAllowThreads();
37880 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37881
37882 wxPyEndAllowThreads(__tstate);
37883 if (PyErr_Occurred()) SWIG_fail;
37884 }
37885 {
37886 resultobj = SWIG_From_int((int)(result));
37887 }
37888 {
37889 if (temp2)
37890 delete arg2;
37891 }
37892 return resultobj;
37893 fail:
37894 {
37895 if (temp2)
37896 delete arg2;
37897 }
37898 return NULL;
37899 }
37900
37901
37902 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37903 PyObject *resultobj;
37904 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37905 PyObject * obj0 = 0 ;
37906 char *kwnames[] = {
37907 (char *) "self", NULL
37908 };
37909
37910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37912 if (SWIG_arg_fail(1)) SWIG_fail;
37913 {
37914 PyThreadState* __tstate = wxPyBeginAllowThreads();
37915 (arg1)->Clear();
37916
37917 wxPyEndAllowThreads(__tstate);
37918 if (PyErr_Occurred()) SWIG_fail;
37919 }
37920 Py_INCREF(Py_None); resultobj = Py_None;
37921 return resultobj;
37922 fail:
37923 return NULL;
37924 }
37925
37926
37927 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37928 PyObject *resultobj;
37929 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37930 int arg2 ;
37931 PyObject * obj0 = 0 ;
37932 PyObject * obj1 = 0 ;
37933 char *kwnames[] = {
37934 (char *) "self",(char *) "n", NULL
37935 };
37936
37937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37939 if (SWIG_arg_fail(1)) SWIG_fail;
37940 {
37941 arg2 = (int)(SWIG_As_int(obj1));
37942 if (SWIG_arg_fail(2)) SWIG_fail;
37943 }
37944 {
37945 PyThreadState* __tstate = wxPyBeginAllowThreads();
37946 (arg1)->Delete(arg2);
37947
37948 wxPyEndAllowThreads(__tstate);
37949 if (PyErr_Occurred()) SWIG_fail;
37950 }
37951 Py_INCREF(Py_None); resultobj = Py_None;
37952 return resultobj;
37953 fail:
37954 return NULL;
37955 }
37956
37957
37958 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37959 PyObject *resultobj;
37960 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37961 int arg2 ;
37962 PyObject *result;
37963 PyObject * obj0 = 0 ;
37964 PyObject * obj1 = 0 ;
37965 char *kwnames[] = {
37966 (char *) "self",(char *) "n", NULL
37967 };
37968
37969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37971 if (SWIG_arg_fail(1)) SWIG_fail;
37972 {
37973 arg2 = (int)(SWIG_As_int(obj1));
37974 if (SWIG_arg_fail(2)) SWIG_fail;
37975 }
37976 {
37977 PyThreadState* __tstate = wxPyBeginAllowThreads();
37978 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37979
37980 wxPyEndAllowThreads(__tstate);
37981 if (PyErr_Occurred()) SWIG_fail;
37982 }
37983 resultobj = result;
37984 return resultobj;
37985 fail:
37986 return NULL;
37987 }
37988
37989
37990 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37991 PyObject *resultobj;
37992 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37993 int arg2 ;
37994 PyObject *arg3 = (PyObject *) 0 ;
37995 PyObject * obj0 = 0 ;
37996 PyObject * obj1 = 0 ;
37997 PyObject * obj2 = 0 ;
37998 char *kwnames[] = {
37999 (char *) "self",(char *) "n",(char *) "clientData", NULL
38000 };
38001
38002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38004 if (SWIG_arg_fail(1)) SWIG_fail;
38005 {
38006 arg2 = (int)(SWIG_As_int(obj1));
38007 if (SWIG_arg_fail(2)) SWIG_fail;
38008 }
38009 arg3 = obj2;
38010 {
38011 PyThreadState* __tstate = wxPyBeginAllowThreads();
38012 wxItemContainer_SetClientData(arg1,arg2,arg3);
38013
38014 wxPyEndAllowThreads(__tstate);
38015 if (PyErr_Occurred()) SWIG_fail;
38016 }
38017 Py_INCREF(Py_None); resultobj = Py_None;
38018 return resultobj;
38019 fail:
38020 return NULL;
38021 }
38022
38023
38024 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38025 PyObject *resultobj;
38026 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38027 int result;
38028 PyObject * obj0 = 0 ;
38029 char *kwnames[] = {
38030 (char *) "self", NULL
38031 };
38032
38033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38035 if (SWIG_arg_fail(1)) SWIG_fail;
38036 {
38037 PyThreadState* __tstate = wxPyBeginAllowThreads();
38038 result = (int)((wxItemContainer const *)arg1)->GetCount();
38039
38040 wxPyEndAllowThreads(__tstate);
38041 if (PyErr_Occurred()) SWIG_fail;
38042 }
38043 {
38044 resultobj = SWIG_From_int((int)(result));
38045 }
38046 return resultobj;
38047 fail:
38048 return NULL;
38049 }
38050
38051
38052 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38053 PyObject *resultobj;
38054 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38055 bool result;
38056 PyObject * obj0 = 0 ;
38057 char *kwnames[] = {
38058 (char *) "self", NULL
38059 };
38060
38061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38063 if (SWIG_arg_fail(1)) SWIG_fail;
38064 {
38065 PyThreadState* __tstate = wxPyBeginAllowThreads();
38066 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38067
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 {
38072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38073 }
38074 return resultobj;
38075 fail:
38076 return NULL;
38077 }
38078
38079
38080 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38081 PyObject *resultobj;
38082 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38083 int arg2 ;
38084 wxString result;
38085 PyObject * obj0 = 0 ;
38086 PyObject * obj1 = 0 ;
38087 char *kwnames[] = {
38088 (char *) "self",(char *) "n", NULL
38089 };
38090
38091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38093 if (SWIG_arg_fail(1)) SWIG_fail;
38094 {
38095 arg2 = (int)(SWIG_As_int(obj1));
38096 if (SWIG_arg_fail(2)) SWIG_fail;
38097 }
38098 {
38099 PyThreadState* __tstate = wxPyBeginAllowThreads();
38100 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38101
38102 wxPyEndAllowThreads(__tstate);
38103 if (PyErr_Occurred()) SWIG_fail;
38104 }
38105 {
38106 #if wxUSE_UNICODE
38107 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38108 #else
38109 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38110 #endif
38111 }
38112 return resultobj;
38113 fail:
38114 return NULL;
38115 }
38116
38117
38118 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38119 PyObject *resultobj;
38120 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38121 wxArrayString result;
38122 PyObject * obj0 = 0 ;
38123 char *kwnames[] = {
38124 (char *) "self", NULL
38125 };
38126
38127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38129 if (SWIG_arg_fail(1)) SWIG_fail;
38130 {
38131 PyThreadState* __tstate = wxPyBeginAllowThreads();
38132 result = ((wxItemContainer const *)arg1)->GetStrings();
38133
38134 wxPyEndAllowThreads(__tstate);
38135 if (PyErr_Occurred()) SWIG_fail;
38136 }
38137 {
38138 resultobj = wxArrayString2PyList_helper(result);
38139 }
38140 return resultobj;
38141 fail:
38142 return NULL;
38143 }
38144
38145
38146 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38147 PyObject *resultobj;
38148 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38149 int arg2 ;
38150 wxString *arg3 = 0 ;
38151 bool temp3 = false ;
38152 PyObject * obj0 = 0 ;
38153 PyObject * obj1 = 0 ;
38154 PyObject * obj2 = 0 ;
38155 char *kwnames[] = {
38156 (char *) "self",(char *) "n",(char *) "s", NULL
38157 };
38158
38159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38161 if (SWIG_arg_fail(1)) SWIG_fail;
38162 {
38163 arg2 = (int)(SWIG_As_int(obj1));
38164 if (SWIG_arg_fail(2)) SWIG_fail;
38165 }
38166 {
38167 arg3 = wxString_in_helper(obj2);
38168 if (arg3 == NULL) SWIG_fail;
38169 temp3 = true;
38170 }
38171 {
38172 PyThreadState* __tstate = wxPyBeginAllowThreads();
38173 (arg1)->SetString(arg2,(wxString const &)*arg3);
38174
38175 wxPyEndAllowThreads(__tstate);
38176 if (PyErr_Occurred()) SWIG_fail;
38177 }
38178 Py_INCREF(Py_None); resultobj = Py_None;
38179 {
38180 if (temp3)
38181 delete arg3;
38182 }
38183 return resultobj;
38184 fail:
38185 {
38186 if (temp3)
38187 delete arg3;
38188 }
38189 return NULL;
38190 }
38191
38192
38193 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38194 PyObject *resultobj;
38195 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38196 wxString *arg2 = 0 ;
38197 int result;
38198 bool temp2 = false ;
38199 PyObject * obj0 = 0 ;
38200 PyObject * obj1 = 0 ;
38201 char *kwnames[] = {
38202 (char *) "self",(char *) "s", NULL
38203 };
38204
38205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38207 if (SWIG_arg_fail(1)) SWIG_fail;
38208 {
38209 arg2 = wxString_in_helper(obj1);
38210 if (arg2 == NULL) SWIG_fail;
38211 temp2 = true;
38212 }
38213 {
38214 PyThreadState* __tstate = wxPyBeginAllowThreads();
38215 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38216
38217 wxPyEndAllowThreads(__tstate);
38218 if (PyErr_Occurred()) SWIG_fail;
38219 }
38220 {
38221 resultobj = SWIG_From_int((int)(result));
38222 }
38223 {
38224 if (temp2)
38225 delete arg2;
38226 }
38227 return resultobj;
38228 fail:
38229 {
38230 if (temp2)
38231 delete arg2;
38232 }
38233 return NULL;
38234 }
38235
38236
38237 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38238 PyObject *resultobj;
38239 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38240 int arg2 ;
38241 PyObject * obj0 = 0 ;
38242 PyObject * obj1 = 0 ;
38243 char *kwnames[] = {
38244 (char *) "self",(char *) "n", NULL
38245 };
38246
38247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38249 if (SWIG_arg_fail(1)) SWIG_fail;
38250 {
38251 arg2 = (int)(SWIG_As_int(obj1));
38252 if (SWIG_arg_fail(2)) SWIG_fail;
38253 }
38254 {
38255 PyThreadState* __tstate = wxPyBeginAllowThreads();
38256 (arg1)->SetSelection(arg2);
38257
38258 wxPyEndAllowThreads(__tstate);
38259 if (PyErr_Occurred()) SWIG_fail;
38260 }
38261 Py_INCREF(Py_None); resultobj = Py_None;
38262 return resultobj;
38263 fail:
38264 return NULL;
38265 }
38266
38267
38268 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38269 PyObject *resultobj;
38270 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38271 int result;
38272 PyObject * obj0 = 0 ;
38273 char *kwnames[] = {
38274 (char *) "self", NULL
38275 };
38276
38277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38279 if (SWIG_arg_fail(1)) SWIG_fail;
38280 {
38281 PyThreadState* __tstate = wxPyBeginAllowThreads();
38282 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38283
38284 wxPyEndAllowThreads(__tstate);
38285 if (PyErr_Occurred()) SWIG_fail;
38286 }
38287 {
38288 resultobj = SWIG_From_int((int)(result));
38289 }
38290 return resultobj;
38291 fail:
38292 return NULL;
38293 }
38294
38295
38296 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38297 PyObject *resultobj;
38298 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38299 wxString *arg2 = 0 ;
38300 bool result;
38301 bool temp2 = false ;
38302 PyObject * obj0 = 0 ;
38303 PyObject * obj1 = 0 ;
38304 char *kwnames[] = {
38305 (char *) "self",(char *) "s", NULL
38306 };
38307
38308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38310 if (SWIG_arg_fail(1)) SWIG_fail;
38311 {
38312 arg2 = wxString_in_helper(obj1);
38313 if (arg2 == NULL) SWIG_fail;
38314 temp2 = true;
38315 }
38316 {
38317 PyThreadState* __tstate = wxPyBeginAllowThreads();
38318 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38319
38320 wxPyEndAllowThreads(__tstate);
38321 if (PyErr_Occurred()) SWIG_fail;
38322 }
38323 {
38324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38325 }
38326 {
38327 if (temp2)
38328 delete arg2;
38329 }
38330 return resultobj;
38331 fail:
38332 {
38333 if (temp2)
38334 delete arg2;
38335 }
38336 return NULL;
38337 }
38338
38339
38340 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38341 PyObject *resultobj;
38342 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38343 wxString result;
38344 PyObject * obj0 = 0 ;
38345 char *kwnames[] = {
38346 (char *) "self", NULL
38347 };
38348
38349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38351 if (SWIG_arg_fail(1)) SWIG_fail;
38352 {
38353 PyThreadState* __tstate = wxPyBeginAllowThreads();
38354 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38355
38356 wxPyEndAllowThreads(__tstate);
38357 if (PyErr_Occurred()) SWIG_fail;
38358 }
38359 {
38360 #if wxUSE_UNICODE
38361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38362 #else
38363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38364 #endif
38365 }
38366 return resultobj;
38367 fail:
38368 return NULL;
38369 }
38370
38371
38372 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38373 PyObject *resultobj;
38374 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38375 int arg2 ;
38376 PyObject * obj0 = 0 ;
38377 PyObject * obj1 = 0 ;
38378 char *kwnames[] = {
38379 (char *) "self",(char *) "n", NULL
38380 };
38381
38382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38384 if (SWIG_arg_fail(1)) SWIG_fail;
38385 {
38386 arg2 = (int)(SWIG_As_int(obj1));
38387 if (SWIG_arg_fail(2)) SWIG_fail;
38388 }
38389 {
38390 PyThreadState* __tstate = wxPyBeginAllowThreads();
38391 (arg1)->Select(arg2);
38392
38393 wxPyEndAllowThreads(__tstate);
38394 if (PyErr_Occurred()) SWIG_fail;
38395 }
38396 Py_INCREF(Py_None); resultobj = Py_None;
38397 return resultobj;
38398 fail:
38399 return NULL;
38400 }
38401
38402
38403 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38404 PyObject *obj;
38405 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38406 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38407 Py_INCREF(obj);
38408 return Py_BuildValue((char *)"");
38409 }
38410 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38411 PyObject *obj;
38412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38413 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38414 Py_INCREF(obj);
38415 return Py_BuildValue((char *)"");
38416 }
38417 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38418 PyObject *resultobj;
38419 wxSizerItem *result;
38420 char *kwnames[] = {
38421 NULL
38422 };
38423
38424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38425 {
38426 PyThreadState* __tstate = wxPyBeginAllowThreads();
38427 result = (wxSizerItem *)new wxSizerItem();
38428
38429 wxPyEndAllowThreads(__tstate);
38430 if (PyErr_Occurred()) SWIG_fail;
38431 }
38432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38433 return resultobj;
38434 fail:
38435 return NULL;
38436 }
38437
38438
38439 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38440 PyObject *resultobj;
38441 wxWindow *arg1 = (wxWindow *) 0 ;
38442 int arg2 ;
38443 int arg3 ;
38444 int arg4 ;
38445 PyObject *arg5 = (PyObject *) NULL ;
38446 wxSizerItem *result;
38447 PyObject * obj0 = 0 ;
38448 PyObject * obj1 = 0 ;
38449 PyObject * obj2 = 0 ;
38450 PyObject * obj3 = 0 ;
38451 PyObject * obj4 = 0 ;
38452 char *kwnames[] = {
38453 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38454 };
38455
38456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38458 if (SWIG_arg_fail(1)) SWIG_fail;
38459 {
38460 arg2 = (int)(SWIG_As_int(obj1));
38461 if (SWIG_arg_fail(2)) SWIG_fail;
38462 }
38463 {
38464 arg3 = (int)(SWIG_As_int(obj2));
38465 if (SWIG_arg_fail(3)) SWIG_fail;
38466 }
38467 {
38468 arg4 = (int)(SWIG_As_int(obj3));
38469 if (SWIG_arg_fail(4)) SWIG_fail;
38470 }
38471 if (obj4) {
38472 arg5 = obj4;
38473 }
38474 {
38475 PyThreadState* __tstate = wxPyBeginAllowThreads();
38476 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38477
38478 wxPyEndAllowThreads(__tstate);
38479 if (PyErr_Occurred()) SWIG_fail;
38480 }
38481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38482 return resultobj;
38483 fail:
38484 return NULL;
38485 }
38486
38487
38488 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38489 PyObject *resultobj;
38490 int arg1 ;
38491 int arg2 ;
38492 int arg3 ;
38493 int arg4 ;
38494 int arg5 ;
38495 PyObject *arg6 = (PyObject *) NULL ;
38496 wxSizerItem *result;
38497 PyObject * obj0 = 0 ;
38498 PyObject * obj1 = 0 ;
38499 PyObject * obj2 = 0 ;
38500 PyObject * obj3 = 0 ;
38501 PyObject * obj4 = 0 ;
38502 PyObject * obj5 = 0 ;
38503 char *kwnames[] = {
38504 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38505 };
38506
38507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38508 {
38509 arg1 = (int)(SWIG_As_int(obj0));
38510 if (SWIG_arg_fail(1)) SWIG_fail;
38511 }
38512 {
38513 arg2 = (int)(SWIG_As_int(obj1));
38514 if (SWIG_arg_fail(2)) SWIG_fail;
38515 }
38516 {
38517 arg3 = (int)(SWIG_As_int(obj2));
38518 if (SWIG_arg_fail(3)) SWIG_fail;
38519 }
38520 {
38521 arg4 = (int)(SWIG_As_int(obj3));
38522 if (SWIG_arg_fail(4)) SWIG_fail;
38523 }
38524 {
38525 arg5 = (int)(SWIG_As_int(obj4));
38526 if (SWIG_arg_fail(5)) SWIG_fail;
38527 }
38528 if (obj5) {
38529 arg6 = obj5;
38530 }
38531 {
38532 PyThreadState* __tstate = wxPyBeginAllowThreads();
38533 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38534
38535 wxPyEndAllowThreads(__tstate);
38536 if (PyErr_Occurred()) SWIG_fail;
38537 }
38538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38539 return resultobj;
38540 fail:
38541 return NULL;
38542 }
38543
38544
38545 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38546 PyObject *resultobj;
38547 wxSizer *arg1 = (wxSizer *) 0 ;
38548 int arg2 ;
38549 int arg3 ;
38550 int arg4 ;
38551 PyObject *arg5 = (PyObject *) NULL ;
38552 wxSizerItem *result;
38553 PyObject * obj0 = 0 ;
38554 PyObject * obj1 = 0 ;
38555 PyObject * obj2 = 0 ;
38556 PyObject * obj3 = 0 ;
38557 PyObject * obj4 = 0 ;
38558 char *kwnames[] = {
38559 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38560 };
38561
38562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38564 if (SWIG_arg_fail(1)) SWIG_fail;
38565 {
38566 arg2 = (int)(SWIG_As_int(obj1));
38567 if (SWIG_arg_fail(2)) SWIG_fail;
38568 }
38569 {
38570 arg3 = (int)(SWIG_As_int(obj2));
38571 if (SWIG_arg_fail(3)) SWIG_fail;
38572 }
38573 {
38574 arg4 = (int)(SWIG_As_int(obj3));
38575 if (SWIG_arg_fail(4)) SWIG_fail;
38576 }
38577 if (obj4) {
38578 arg5 = obj4;
38579 }
38580 {
38581 PyThreadState* __tstate = wxPyBeginAllowThreads();
38582 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38583
38584 wxPyEndAllowThreads(__tstate);
38585 if (PyErr_Occurred()) SWIG_fail;
38586 }
38587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38588 return resultobj;
38589 fail:
38590 return NULL;
38591 }
38592
38593
38594 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38595 PyObject *resultobj;
38596 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38597 PyObject * obj0 = 0 ;
38598 char *kwnames[] = {
38599 (char *) "self", NULL
38600 };
38601
38602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38604 if (SWIG_arg_fail(1)) SWIG_fail;
38605 {
38606 PyThreadState* __tstate = wxPyBeginAllowThreads();
38607 (arg1)->DeleteWindows();
38608
38609 wxPyEndAllowThreads(__tstate);
38610 if (PyErr_Occurred()) SWIG_fail;
38611 }
38612 Py_INCREF(Py_None); resultobj = Py_None;
38613 return resultobj;
38614 fail:
38615 return NULL;
38616 }
38617
38618
38619 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38620 PyObject *resultobj;
38621 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38622 PyObject * obj0 = 0 ;
38623 char *kwnames[] = {
38624 (char *) "self", NULL
38625 };
38626
38627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38629 if (SWIG_arg_fail(1)) SWIG_fail;
38630 {
38631 PyThreadState* __tstate = wxPyBeginAllowThreads();
38632 (arg1)->DetachSizer();
38633
38634 wxPyEndAllowThreads(__tstate);
38635 if (PyErr_Occurred()) SWIG_fail;
38636 }
38637 Py_INCREF(Py_None); resultobj = Py_None;
38638 return resultobj;
38639 fail:
38640 return NULL;
38641 }
38642
38643
38644 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38645 PyObject *resultobj;
38646 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38647 wxSize result;
38648 PyObject * obj0 = 0 ;
38649 char *kwnames[] = {
38650 (char *) "self", NULL
38651 };
38652
38653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38655 if (SWIG_arg_fail(1)) SWIG_fail;
38656 {
38657 PyThreadState* __tstate = wxPyBeginAllowThreads();
38658 result = (arg1)->GetSize();
38659
38660 wxPyEndAllowThreads(__tstate);
38661 if (PyErr_Occurred()) SWIG_fail;
38662 }
38663 {
38664 wxSize * resultptr;
38665 resultptr = new wxSize((wxSize &)(result));
38666 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38667 }
38668 return resultobj;
38669 fail:
38670 return NULL;
38671 }
38672
38673
38674 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38675 PyObject *resultobj;
38676 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38677 wxSize result;
38678 PyObject * obj0 = 0 ;
38679 char *kwnames[] = {
38680 (char *) "self", NULL
38681 };
38682
38683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38685 if (SWIG_arg_fail(1)) SWIG_fail;
38686 {
38687 PyThreadState* __tstate = wxPyBeginAllowThreads();
38688 result = (arg1)->CalcMin();
38689
38690 wxPyEndAllowThreads(__tstate);
38691 if (PyErr_Occurred()) SWIG_fail;
38692 }
38693 {
38694 wxSize * resultptr;
38695 resultptr = new wxSize((wxSize &)(result));
38696 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38697 }
38698 return resultobj;
38699 fail:
38700 return NULL;
38701 }
38702
38703
38704 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38705 PyObject *resultobj;
38706 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38707 wxPoint arg2 ;
38708 wxSize arg3 ;
38709 PyObject * obj0 = 0 ;
38710 PyObject * obj1 = 0 ;
38711 PyObject * obj2 = 0 ;
38712 char *kwnames[] = {
38713 (char *) "self",(char *) "pos",(char *) "size", NULL
38714 };
38715
38716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38718 if (SWIG_arg_fail(1)) SWIG_fail;
38719 {
38720 wxPoint * argp;
38721 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38722 if (SWIG_arg_fail(2)) SWIG_fail;
38723 if (argp == NULL) {
38724 SWIG_null_ref("wxPoint");
38725 }
38726 if (SWIG_arg_fail(2)) SWIG_fail;
38727 arg2 = *argp;
38728 }
38729 {
38730 wxSize * argp;
38731 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38732 if (SWIG_arg_fail(3)) SWIG_fail;
38733 if (argp == NULL) {
38734 SWIG_null_ref("wxSize");
38735 }
38736 if (SWIG_arg_fail(3)) SWIG_fail;
38737 arg3 = *argp;
38738 }
38739 {
38740 PyThreadState* __tstate = wxPyBeginAllowThreads();
38741 (arg1)->SetDimension(arg2,arg3);
38742
38743 wxPyEndAllowThreads(__tstate);
38744 if (PyErr_Occurred()) SWIG_fail;
38745 }
38746 Py_INCREF(Py_None); resultobj = Py_None;
38747 return resultobj;
38748 fail:
38749 return NULL;
38750 }
38751
38752
38753 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38754 PyObject *resultobj;
38755 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38756 wxSize result;
38757 PyObject * obj0 = 0 ;
38758 char *kwnames[] = {
38759 (char *) "self", NULL
38760 };
38761
38762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38764 if (SWIG_arg_fail(1)) SWIG_fail;
38765 {
38766 PyThreadState* __tstate = wxPyBeginAllowThreads();
38767 result = (arg1)->GetMinSize();
38768
38769 wxPyEndAllowThreads(__tstate);
38770 if (PyErr_Occurred()) SWIG_fail;
38771 }
38772 {
38773 wxSize * resultptr;
38774 resultptr = new wxSize((wxSize &)(result));
38775 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38776 }
38777 return resultobj;
38778 fail:
38779 return NULL;
38780 }
38781
38782
38783 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38784 PyObject *resultobj;
38785 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38786 wxSize result;
38787 PyObject * obj0 = 0 ;
38788 char *kwnames[] = {
38789 (char *) "self", NULL
38790 };
38791
38792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38794 if (SWIG_arg_fail(1)) SWIG_fail;
38795 {
38796 PyThreadState* __tstate = wxPyBeginAllowThreads();
38797 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38798
38799 wxPyEndAllowThreads(__tstate);
38800 if (PyErr_Occurred()) SWIG_fail;
38801 }
38802 {
38803 wxSize * resultptr;
38804 resultptr = new wxSize((wxSize &)(result));
38805 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38806 }
38807 return resultobj;
38808 fail:
38809 return NULL;
38810 }
38811
38812
38813 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38814 PyObject *resultobj;
38815 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38816 int arg2 ;
38817 int arg3 ;
38818 PyObject * obj0 = 0 ;
38819 PyObject * obj1 = 0 ;
38820 PyObject * obj2 = 0 ;
38821 char *kwnames[] = {
38822 (char *) "self",(char *) "x",(char *) "y", NULL
38823 };
38824
38825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38827 if (SWIG_arg_fail(1)) SWIG_fail;
38828 {
38829 arg2 = (int)(SWIG_As_int(obj1));
38830 if (SWIG_arg_fail(2)) SWIG_fail;
38831 }
38832 {
38833 arg3 = (int)(SWIG_As_int(obj2));
38834 if (SWIG_arg_fail(3)) SWIG_fail;
38835 }
38836 {
38837 PyThreadState* __tstate = wxPyBeginAllowThreads();
38838 (arg1)->SetInitSize(arg2,arg3);
38839
38840 wxPyEndAllowThreads(__tstate);
38841 if (PyErr_Occurred()) SWIG_fail;
38842 }
38843 Py_INCREF(Py_None); resultobj = Py_None;
38844 return resultobj;
38845 fail:
38846 return NULL;
38847 }
38848
38849
38850 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38851 PyObject *resultobj;
38852 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38853 int arg2 ;
38854 int arg3 ;
38855 PyObject * obj0 = 0 ;
38856 PyObject * obj1 = 0 ;
38857 PyObject * obj2 = 0 ;
38858 char *kwnames[] = {
38859 (char *) "self",(char *) "width",(char *) "height", NULL
38860 };
38861
38862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) 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 = (int)(SWIG_As_int(obj1));
38867 if (SWIG_arg_fail(2)) SWIG_fail;
38868 }
38869 {
38870 arg3 = (int)(SWIG_As_int(obj2));
38871 if (SWIG_arg_fail(3)) SWIG_fail;
38872 }
38873 {
38874 PyThreadState* __tstate = wxPyBeginAllowThreads();
38875 (arg1)->SetRatio(arg2,arg3);
38876
38877 wxPyEndAllowThreads(__tstate);
38878 if (PyErr_Occurred()) SWIG_fail;
38879 }
38880 Py_INCREF(Py_None); resultobj = Py_None;
38881 return resultobj;
38882 fail:
38883 return NULL;
38884 }
38885
38886
38887 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38888 PyObject *resultobj;
38889 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38890 wxSize *arg2 = 0 ;
38891 wxSize temp2 ;
38892 PyObject * obj0 = 0 ;
38893 PyObject * obj1 = 0 ;
38894 char *kwnames[] = {
38895 (char *) "self",(char *) "size", NULL
38896 };
38897
38898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38900 if (SWIG_arg_fail(1)) SWIG_fail;
38901 {
38902 arg2 = &temp2;
38903 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38904 }
38905 {
38906 PyThreadState* __tstate = wxPyBeginAllowThreads();
38907 (arg1)->SetRatio((wxSize const &)*arg2);
38908
38909 wxPyEndAllowThreads(__tstate);
38910 if (PyErr_Occurred()) SWIG_fail;
38911 }
38912 Py_INCREF(Py_None); resultobj = Py_None;
38913 return resultobj;
38914 fail:
38915 return NULL;
38916 }
38917
38918
38919 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38920 PyObject *resultobj;
38921 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38922 float arg2 ;
38923 PyObject * obj0 = 0 ;
38924 PyObject * obj1 = 0 ;
38925 char *kwnames[] = {
38926 (char *) "self",(char *) "ratio", NULL
38927 };
38928
38929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38931 if (SWIG_arg_fail(1)) SWIG_fail;
38932 {
38933 arg2 = (float)(SWIG_As_float(obj1));
38934 if (SWIG_arg_fail(2)) SWIG_fail;
38935 }
38936 {
38937 PyThreadState* __tstate = wxPyBeginAllowThreads();
38938 (arg1)->SetRatio(arg2);
38939
38940 wxPyEndAllowThreads(__tstate);
38941 if (PyErr_Occurred()) SWIG_fail;
38942 }
38943 Py_INCREF(Py_None); resultobj = Py_None;
38944 return resultobj;
38945 fail:
38946 return NULL;
38947 }
38948
38949
38950 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38951 PyObject *resultobj;
38952 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38953 float result;
38954 PyObject * obj0 = 0 ;
38955 char *kwnames[] = {
38956 (char *) "self", NULL
38957 };
38958
38959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38961 if (SWIG_arg_fail(1)) SWIG_fail;
38962 {
38963 PyThreadState* __tstate = wxPyBeginAllowThreads();
38964 result = (float)(arg1)->GetRatio();
38965
38966 wxPyEndAllowThreads(__tstate);
38967 if (PyErr_Occurred()) SWIG_fail;
38968 }
38969 {
38970 resultobj = SWIG_From_float((float)(result));
38971 }
38972 return resultobj;
38973 fail:
38974 return NULL;
38975 }
38976
38977
38978 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38979 PyObject *resultobj;
38980 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38981 wxRect result;
38982 PyObject * obj0 = 0 ;
38983 char *kwnames[] = {
38984 (char *) "self", NULL
38985 };
38986
38987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38989 if (SWIG_arg_fail(1)) SWIG_fail;
38990 {
38991 PyThreadState* __tstate = wxPyBeginAllowThreads();
38992 result = (arg1)->GetRect();
38993
38994 wxPyEndAllowThreads(__tstate);
38995 if (PyErr_Occurred()) SWIG_fail;
38996 }
38997 {
38998 wxRect * resultptr;
38999 resultptr = new wxRect((wxRect &)(result));
39000 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39001 }
39002 return resultobj;
39003 fail:
39004 return NULL;
39005 }
39006
39007
39008 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39009 PyObject *resultobj;
39010 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39011 bool result;
39012 PyObject * obj0 = 0 ;
39013 char *kwnames[] = {
39014 (char *) "self", NULL
39015 };
39016
39017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39019 if (SWIG_arg_fail(1)) SWIG_fail;
39020 {
39021 PyThreadState* __tstate = wxPyBeginAllowThreads();
39022 result = (bool)(arg1)->IsWindow();
39023
39024 wxPyEndAllowThreads(__tstate);
39025 if (PyErr_Occurred()) SWIG_fail;
39026 }
39027 {
39028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39029 }
39030 return resultobj;
39031 fail:
39032 return NULL;
39033 }
39034
39035
39036 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39037 PyObject *resultobj;
39038 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39039 bool result;
39040 PyObject * obj0 = 0 ;
39041 char *kwnames[] = {
39042 (char *) "self", NULL
39043 };
39044
39045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39047 if (SWIG_arg_fail(1)) SWIG_fail;
39048 {
39049 PyThreadState* __tstate = wxPyBeginAllowThreads();
39050 result = (bool)(arg1)->IsSizer();
39051
39052 wxPyEndAllowThreads(__tstate);
39053 if (PyErr_Occurred()) SWIG_fail;
39054 }
39055 {
39056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39057 }
39058 return resultobj;
39059 fail:
39060 return NULL;
39061 }
39062
39063
39064 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39065 PyObject *resultobj;
39066 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39067 bool result;
39068 PyObject * obj0 = 0 ;
39069 char *kwnames[] = {
39070 (char *) "self", NULL
39071 };
39072
39073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39075 if (SWIG_arg_fail(1)) SWIG_fail;
39076 {
39077 PyThreadState* __tstate = wxPyBeginAllowThreads();
39078 result = (bool)(arg1)->IsSpacer();
39079
39080 wxPyEndAllowThreads(__tstate);
39081 if (PyErr_Occurred()) SWIG_fail;
39082 }
39083 {
39084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39085 }
39086 return resultobj;
39087 fail:
39088 return NULL;
39089 }
39090
39091
39092 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39093 PyObject *resultobj;
39094 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39095 int arg2 ;
39096 PyObject * obj0 = 0 ;
39097 PyObject * obj1 = 0 ;
39098 char *kwnames[] = {
39099 (char *) "self",(char *) "proportion", NULL
39100 };
39101
39102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39104 if (SWIG_arg_fail(1)) SWIG_fail;
39105 {
39106 arg2 = (int)(SWIG_As_int(obj1));
39107 if (SWIG_arg_fail(2)) SWIG_fail;
39108 }
39109 {
39110 PyThreadState* __tstate = wxPyBeginAllowThreads();
39111 (arg1)->SetProportion(arg2);
39112
39113 wxPyEndAllowThreads(__tstate);
39114 if (PyErr_Occurred()) SWIG_fail;
39115 }
39116 Py_INCREF(Py_None); resultobj = Py_None;
39117 return resultobj;
39118 fail:
39119 return NULL;
39120 }
39121
39122
39123 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39124 PyObject *resultobj;
39125 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39126 int result;
39127 PyObject * obj0 = 0 ;
39128 char *kwnames[] = {
39129 (char *) "self", NULL
39130 };
39131
39132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39134 if (SWIG_arg_fail(1)) SWIG_fail;
39135 {
39136 PyThreadState* __tstate = wxPyBeginAllowThreads();
39137 result = (int)(arg1)->GetProportion();
39138
39139 wxPyEndAllowThreads(__tstate);
39140 if (PyErr_Occurred()) SWIG_fail;
39141 }
39142 {
39143 resultobj = SWIG_From_int((int)(result));
39144 }
39145 return resultobj;
39146 fail:
39147 return NULL;
39148 }
39149
39150
39151 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39152 PyObject *resultobj;
39153 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39154 int arg2 ;
39155 PyObject * obj0 = 0 ;
39156 PyObject * obj1 = 0 ;
39157 char *kwnames[] = {
39158 (char *) "self",(char *) "flag", NULL
39159 };
39160
39161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39163 if (SWIG_arg_fail(1)) SWIG_fail;
39164 {
39165 arg2 = (int)(SWIG_As_int(obj1));
39166 if (SWIG_arg_fail(2)) SWIG_fail;
39167 }
39168 {
39169 PyThreadState* __tstate = wxPyBeginAllowThreads();
39170 (arg1)->SetFlag(arg2);
39171
39172 wxPyEndAllowThreads(__tstate);
39173 if (PyErr_Occurred()) SWIG_fail;
39174 }
39175 Py_INCREF(Py_None); resultobj = Py_None;
39176 return resultobj;
39177 fail:
39178 return NULL;
39179 }
39180
39181
39182 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39183 PyObject *resultobj;
39184 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39185 int result;
39186 PyObject * obj0 = 0 ;
39187 char *kwnames[] = {
39188 (char *) "self", NULL
39189 };
39190
39191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39193 if (SWIG_arg_fail(1)) SWIG_fail;
39194 {
39195 PyThreadState* __tstate = wxPyBeginAllowThreads();
39196 result = (int)(arg1)->GetFlag();
39197
39198 wxPyEndAllowThreads(__tstate);
39199 if (PyErr_Occurred()) SWIG_fail;
39200 }
39201 {
39202 resultobj = SWIG_From_int((int)(result));
39203 }
39204 return resultobj;
39205 fail:
39206 return NULL;
39207 }
39208
39209
39210 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39211 PyObject *resultobj;
39212 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39213 int arg2 ;
39214 PyObject * obj0 = 0 ;
39215 PyObject * obj1 = 0 ;
39216 char *kwnames[] = {
39217 (char *) "self",(char *) "border", NULL
39218 };
39219
39220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39222 if (SWIG_arg_fail(1)) SWIG_fail;
39223 {
39224 arg2 = (int)(SWIG_As_int(obj1));
39225 if (SWIG_arg_fail(2)) SWIG_fail;
39226 }
39227 {
39228 PyThreadState* __tstate = wxPyBeginAllowThreads();
39229 (arg1)->SetBorder(arg2);
39230
39231 wxPyEndAllowThreads(__tstate);
39232 if (PyErr_Occurred()) SWIG_fail;
39233 }
39234 Py_INCREF(Py_None); resultobj = Py_None;
39235 return resultobj;
39236 fail:
39237 return NULL;
39238 }
39239
39240
39241 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39242 PyObject *resultobj;
39243 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39244 int result;
39245 PyObject * obj0 = 0 ;
39246 char *kwnames[] = {
39247 (char *) "self", NULL
39248 };
39249
39250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39252 if (SWIG_arg_fail(1)) SWIG_fail;
39253 {
39254 PyThreadState* __tstate = wxPyBeginAllowThreads();
39255 result = (int)(arg1)->GetBorder();
39256
39257 wxPyEndAllowThreads(__tstate);
39258 if (PyErr_Occurred()) SWIG_fail;
39259 }
39260 {
39261 resultobj = SWIG_From_int((int)(result));
39262 }
39263 return resultobj;
39264 fail:
39265 return NULL;
39266 }
39267
39268
39269 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39270 PyObject *resultobj;
39271 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39272 wxWindow *result;
39273 PyObject * obj0 = 0 ;
39274 char *kwnames[] = {
39275 (char *) "self", NULL
39276 };
39277
39278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39280 if (SWIG_arg_fail(1)) SWIG_fail;
39281 {
39282 PyThreadState* __tstate = wxPyBeginAllowThreads();
39283 result = (wxWindow *)(arg1)->GetWindow();
39284
39285 wxPyEndAllowThreads(__tstate);
39286 if (PyErr_Occurred()) SWIG_fail;
39287 }
39288 {
39289 resultobj = wxPyMake_wxObject(result, 0);
39290 }
39291 return resultobj;
39292 fail:
39293 return NULL;
39294 }
39295
39296
39297 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39298 PyObject *resultobj;
39299 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39300 wxWindow *arg2 = (wxWindow *) 0 ;
39301 PyObject * obj0 = 0 ;
39302 PyObject * obj1 = 0 ;
39303 char *kwnames[] = {
39304 (char *) "self",(char *) "window", NULL
39305 };
39306
39307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39309 if (SWIG_arg_fail(1)) SWIG_fail;
39310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39311 if (SWIG_arg_fail(2)) SWIG_fail;
39312 {
39313 PyThreadState* __tstate = wxPyBeginAllowThreads();
39314 (arg1)->SetWindow(arg2);
39315
39316 wxPyEndAllowThreads(__tstate);
39317 if (PyErr_Occurred()) SWIG_fail;
39318 }
39319 Py_INCREF(Py_None); resultobj = Py_None;
39320 return resultobj;
39321 fail:
39322 return NULL;
39323 }
39324
39325
39326 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39327 PyObject *resultobj;
39328 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39329 wxSizer *result;
39330 PyObject * obj0 = 0 ;
39331 char *kwnames[] = {
39332 (char *) "self", NULL
39333 };
39334
39335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39337 if (SWIG_arg_fail(1)) SWIG_fail;
39338 {
39339 PyThreadState* __tstate = wxPyBeginAllowThreads();
39340 result = (wxSizer *)(arg1)->GetSizer();
39341
39342 wxPyEndAllowThreads(__tstate);
39343 if (PyErr_Occurred()) SWIG_fail;
39344 }
39345 {
39346 resultobj = wxPyMake_wxObject(result, 0);
39347 }
39348 return resultobj;
39349 fail:
39350 return NULL;
39351 }
39352
39353
39354 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39355 PyObject *resultobj;
39356 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39357 wxSizer *arg2 = (wxSizer *) 0 ;
39358 PyObject * obj0 = 0 ;
39359 PyObject * obj1 = 0 ;
39360 char *kwnames[] = {
39361 (char *) "self",(char *) "sizer", NULL
39362 };
39363
39364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39366 if (SWIG_arg_fail(1)) SWIG_fail;
39367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39368 if (SWIG_arg_fail(2)) SWIG_fail;
39369 {
39370 PyThreadState* __tstate = wxPyBeginAllowThreads();
39371 (arg1)->SetSizer(arg2);
39372
39373 wxPyEndAllowThreads(__tstate);
39374 if (PyErr_Occurred()) SWIG_fail;
39375 }
39376 Py_INCREF(Py_None); resultobj = Py_None;
39377 return resultobj;
39378 fail:
39379 return NULL;
39380 }
39381
39382
39383 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39384 PyObject *resultobj;
39385 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39386 wxSize *result;
39387 PyObject * obj0 = 0 ;
39388 char *kwnames[] = {
39389 (char *) "self", NULL
39390 };
39391
39392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39394 if (SWIG_arg_fail(1)) SWIG_fail;
39395 {
39396 PyThreadState* __tstate = wxPyBeginAllowThreads();
39397 {
39398 wxSize const &_result_ref = (arg1)->GetSpacer();
39399 result = (wxSize *) &_result_ref;
39400 }
39401
39402 wxPyEndAllowThreads(__tstate);
39403 if (PyErr_Occurred()) SWIG_fail;
39404 }
39405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39406 return resultobj;
39407 fail:
39408 return NULL;
39409 }
39410
39411
39412 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39413 PyObject *resultobj;
39414 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39415 wxSize *arg2 = 0 ;
39416 wxSize temp2 ;
39417 PyObject * obj0 = 0 ;
39418 PyObject * obj1 = 0 ;
39419 char *kwnames[] = {
39420 (char *) "self",(char *) "size", NULL
39421 };
39422
39423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39425 if (SWIG_arg_fail(1)) SWIG_fail;
39426 {
39427 arg2 = &temp2;
39428 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39429 }
39430 {
39431 PyThreadState* __tstate = wxPyBeginAllowThreads();
39432 (arg1)->SetSpacer((wxSize const &)*arg2);
39433
39434 wxPyEndAllowThreads(__tstate);
39435 if (PyErr_Occurred()) SWIG_fail;
39436 }
39437 Py_INCREF(Py_None); resultobj = Py_None;
39438 return resultobj;
39439 fail:
39440 return NULL;
39441 }
39442
39443
39444 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39445 PyObject *resultobj;
39446 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39447 bool arg2 ;
39448 PyObject * obj0 = 0 ;
39449 PyObject * obj1 = 0 ;
39450 char *kwnames[] = {
39451 (char *) "self",(char *) "show", NULL
39452 };
39453
39454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39456 if (SWIG_arg_fail(1)) SWIG_fail;
39457 {
39458 arg2 = (bool)(SWIG_As_bool(obj1));
39459 if (SWIG_arg_fail(2)) SWIG_fail;
39460 }
39461 {
39462 PyThreadState* __tstate = wxPyBeginAllowThreads();
39463 (arg1)->Show(arg2);
39464
39465 wxPyEndAllowThreads(__tstate);
39466 if (PyErr_Occurred()) SWIG_fail;
39467 }
39468 Py_INCREF(Py_None); resultobj = Py_None;
39469 return resultobj;
39470 fail:
39471 return NULL;
39472 }
39473
39474
39475 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39476 PyObject *resultobj;
39477 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39478 bool result;
39479 PyObject * obj0 = 0 ;
39480 char *kwnames[] = {
39481 (char *) "self", NULL
39482 };
39483
39484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39486 if (SWIG_arg_fail(1)) SWIG_fail;
39487 {
39488 PyThreadState* __tstate = wxPyBeginAllowThreads();
39489 result = (bool)(arg1)->IsShown();
39490
39491 wxPyEndAllowThreads(__tstate);
39492 if (PyErr_Occurred()) SWIG_fail;
39493 }
39494 {
39495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39496 }
39497 return resultobj;
39498 fail:
39499 return NULL;
39500 }
39501
39502
39503 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39504 PyObject *resultobj;
39505 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39506 wxPoint result;
39507 PyObject * obj0 = 0 ;
39508 char *kwnames[] = {
39509 (char *) "self", NULL
39510 };
39511
39512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39514 if (SWIG_arg_fail(1)) SWIG_fail;
39515 {
39516 PyThreadState* __tstate = wxPyBeginAllowThreads();
39517 result = (arg1)->GetPosition();
39518
39519 wxPyEndAllowThreads(__tstate);
39520 if (PyErr_Occurred()) SWIG_fail;
39521 }
39522 {
39523 wxPoint * resultptr;
39524 resultptr = new wxPoint((wxPoint &)(result));
39525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39526 }
39527 return resultobj;
39528 fail:
39529 return NULL;
39530 }
39531
39532
39533 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39534 PyObject *resultobj;
39535 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39536 PyObject *result;
39537 PyObject * obj0 = 0 ;
39538 char *kwnames[] = {
39539 (char *) "self", NULL
39540 };
39541
39542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39544 if (SWIG_arg_fail(1)) SWIG_fail;
39545 {
39546 PyThreadState* __tstate = wxPyBeginAllowThreads();
39547 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39548
39549 wxPyEndAllowThreads(__tstate);
39550 if (PyErr_Occurred()) SWIG_fail;
39551 }
39552 resultobj = result;
39553 return resultobj;
39554 fail:
39555 return NULL;
39556 }
39557
39558
39559 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39560 PyObject *obj;
39561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39562 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39563 Py_INCREF(obj);
39564 return Py_BuildValue((char *)"");
39565 }
39566 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39567 PyObject *resultobj;
39568 wxSizer *arg1 = (wxSizer *) 0 ;
39569 PyObject *arg2 = (PyObject *) 0 ;
39570 PyObject * obj0 = 0 ;
39571 PyObject * obj1 = 0 ;
39572 char *kwnames[] = {
39573 (char *) "self",(char *) "_self", NULL
39574 };
39575
39576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39578 if (SWIG_arg_fail(1)) SWIG_fail;
39579 arg2 = obj1;
39580 {
39581 PyThreadState* __tstate = wxPyBeginAllowThreads();
39582 wxSizer__setOORInfo(arg1,arg2);
39583
39584 wxPyEndAllowThreads(__tstate);
39585 if (PyErr_Occurred()) SWIG_fail;
39586 }
39587 Py_INCREF(Py_None); resultobj = Py_None;
39588 return resultobj;
39589 fail:
39590 return NULL;
39591 }
39592
39593
39594 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39595 PyObject *resultobj;
39596 wxSizer *arg1 = (wxSizer *) 0 ;
39597 PyObject *arg2 = (PyObject *) 0 ;
39598 int arg3 = (int) 0 ;
39599 int arg4 = (int) 0 ;
39600 int arg5 = (int) 0 ;
39601 PyObject *arg6 = (PyObject *) NULL ;
39602 wxSizerItem *result;
39603 PyObject * obj0 = 0 ;
39604 PyObject * obj1 = 0 ;
39605 PyObject * obj2 = 0 ;
39606 PyObject * obj3 = 0 ;
39607 PyObject * obj4 = 0 ;
39608 PyObject * obj5 = 0 ;
39609 char *kwnames[] = {
39610 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39611 };
39612
39613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39615 if (SWIG_arg_fail(1)) SWIG_fail;
39616 arg2 = obj1;
39617 if (obj2) {
39618 {
39619 arg3 = (int)(SWIG_As_int(obj2));
39620 if (SWIG_arg_fail(3)) SWIG_fail;
39621 }
39622 }
39623 if (obj3) {
39624 {
39625 arg4 = (int)(SWIG_As_int(obj3));
39626 if (SWIG_arg_fail(4)) SWIG_fail;
39627 }
39628 }
39629 if (obj4) {
39630 {
39631 arg5 = (int)(SWIG_As_int(obj4));
39632 if (SWIG_arg_fail(5)) SWIG_fail;
39633 }
39634 }
39635 if (obj5) {
39636 arg6 = obj5;
39637 }
39638 {
39639 PyThreadState* __tstate = wxPyBeginAllowThreads();
39640 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39641
39642 wxPyEndAllowThreads(__tstate);
39643 if (PyErr_Occurred()) SWIG_fail;
39644 }
39645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39646 return resultobj;
39647 fail:
39648 return NULL;
39649 }
39650
39651
39652 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39653 PyObject *resultobj;
39654 wxSizer *arg1 = (wxSizer *) 0 ;
39655 int arg2 ;
39656 PyObject *arg3 = (PyObject *) 0 ;
39657 int arg4 = (int) 0 ;
39658 int arg5 = (int) 0 ;
39659 int arg6 = (int) 0 ;
39660 PyObject *arg7 = (PyObject *) NULL ;
39661 wxSizerItem *result;
39662 PyObject * obj0 = 0 ;
39663 PyObject * obj1 = 0 ;
39664 PyObject * obj2 = 0 ;
39665 PyObject * obj3 = 0 ;
39666 PyObject * obj4 = 0 ;
39667 PyObject * obj5 = 0 ;
39668 PyObject * obj6 = 0 ;
39669 char *kwnames[] = {
39670 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39671 };
39672
39673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39675 if (SWIG_arg_fail(1)) SWIG_fail;
39676 {
39677 arg2 = (int)(SWIG_As_int(obj1));
39678 if (SWIG_arg_fail(2)) SWIG_fail;
39679 }
39680 arg3 = obj2;
39681 if (obj3) {
39682 {
39683 arg4 = (int)(SWIG_As_int(obj3));
39684 if (SWIG_arg_fail(4)) SWIG_fail;
39685 }
39686 }
39687 if (obj4) {
39688 {
39689 arg5 = (int)(SWIG_As_int(obj4));
39690 if (SWIG_arg_fail(5)) SWIG_fail;
39691 }
39692 }
39693 if (obj5) {
39694 {
39695 arg6 = (int)(SWIG_As_int(obj5));
39696 if (SWIG_arg_fail(6)) SWIG_fail;
39697 }
39698 }
39699 if (obj6) {
39700 arg7 = obj6;
39701 }
39702 {
39703 PyThreadState* __tstate = wxPyBeginAllowThreads();
39704 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39705
39706 wxPyEndAllowThreads(__tstate);
39707 if (PyErr_Occurred()) SWIG_fail;
39708 }
39709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39710 return resultobj;
39711 fail:
39712 return NULL;
39713 }
39714
39715
39716 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39717 PyObject *resultobj;
39718 wxSizer *arg1 = (wxSizer *) 0 ;
39719 PyObject *arg2 = (PyObject *) 0 ;
39720 int arg3 = (int) 0 ;
39721 int arg4 = (int) 0 ;
39722 int arg5 = (int) 0 ;
39723 PyObject *arg6 = (PyObject *) NULL ;
39724 wxSizerItem *result;
39725 PyObject * obj0 = 0 ;
39726 PyObject * obj1 = 0 ;
39727 PyObject * obj2 = 0 ;
39728 PyObject * obj3 = 0 ;
39729 PyObject * obj4 = 0 ;
39730 PyObject * obj5 = 0 ;
39731 char *kwnames[] = {
39732 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39733 };
39734
39735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39737 if (SWIG_arg_fail(1)) SWIG_fail;
39738 arg2 = obj1;
39739 if (obj2) {
39740 {
39741 arg3 = (int)(SWIG_As_int(obj2));
39742 if (SWIG_arg_fail(3)) SWIG_fail;
39743 }
39744 }
39745 if (obj3) {
39746 {
39747 arg4 = (int)(SWIG_As_int(obj3));
39748 if (SWIG_arg_fail(4)) SWIG_fail;
39749 }
39750 }
39751 if (obj4) {
39752 {
39753 arg5 = (int)(SWIG_As_int(obj4));
39754 if (SWIG_arg_fail(5)) SWIG_fail;
39755 }
39756 }
39757 if (obj5) {
39758 arg6 = obj5;
39759 }
39760 {
39761 PyThreadState* __tstate = wxPyBeginAllowThreads();
39762 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39763
39764 wxPyEndAllowThreads(__tstate);
39765 if (PyErr_Occurred()) SWIG_fail;
39766 }
39767 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39768 return resultobj;
39769 fail:
39770 return NULL;
39771 }
39772
39773
39774 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39775 PyObject *resultobj;
39776 wxSizer *arg1 = (wxSizer *) 0 ;
39777 PyObject *arg2 = (PyObject *) 0 ;
39778 bool result;
39779 PyObject * obj0 = 0 ;
39780 PyObject * obj1 = 0 ;
39781 char *kwnames[] = {
39782 (char *) "self",(char *) "item", NULL
39783 };
39784
39785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39787 if (SWIG_arg_fail(1)) SWIG_fail;
39788 arg2 = obj1;
39789 {
39790 PyThreadState* __tstate = wxPyBeginAllowThreads();
39791 result = (bool)wxSizer_Remove(arg1,arg2);
39792
39793 wxPyEndAllowThreads(__tstate);
39794 if (PyErr_Occurred()) SWIG_fail;
39795 }
39796 {
39797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39798 }
39799 return resultobj;
39800 fail:
39801 return NULL;
39802 }
39803
39804
39805 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39806 PyObject *resultobj;
39807 wxSizer *arg1 = (wxSizer *) 0 ;
39808 PyObject *arg2 = (PyObject *) 0 ;
39809 bool result;
39810 PyObject * obj0 = 0 ;
39811 PyObject * obj1 = 0 ;
39812 char *kwnames[] = {
39813 (char *) "self",(char *) "item", NULL
39814 };
39815
39816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39818 if (SWIG_arg_fail(1)) SWIG_fail;
39819 arg2 = obj1;
39820 {
39821 PyThreadState* __tstate = wxPyBeginAllowThreads();
39822 result = (bool)wxSizer_Detach(arg1,arg2);
39823
39824 wxPyEndAllowThreads(__tstate);
39825 if (PyErr_Occurred()) SWIG_fail;
39826 }
39827 {
39828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39829 }
39830 return resultobj;
39831 fail:
39832 return NULL;
39833 }
39834
39835
39836 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39837 PyObject *resultobj;
39838 wxSizer *arg1 = (wxSizer *) 0 ;
39839 PyObject *arg2 = (PyObject *) 0 ;
39840 wxSizerItem *result;
39841 PyObject * obj0 = 0 ;
39842 PyObject * obj1 = 0 ;
39843 char *kwnames[] = {
39844 (char *) "self",(char *) "item", NULL
39845 };
39846
39847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39849 if (SWIG_arg_fail(1)) SWIG_fail;
39850 arg2 = obj1;
39851 {
39852 PyThreadState* __tstate = wxPyBeginAllowThreads();
39853 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39854
39855 wxPyEndAllowThreads(__tstate);
39856 if (PyErr_Occurred()) SWIG_fail;
39857 }
39858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39859 return resultobj;
39860 fail:
39861 return NULL;
39862 }
39863
39864
39865 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39866 PyObject *resultobj;
39867 wxSizer *arg1 = (wxSizer *) 0 ;
39868 PyObject *arg2 = (PyObject *) 0 ;
39869 wxSize *arg3 = 0 ;
39870 wxSize temp3 ;
39871 PyObject * obj0 = 0 ;
39872 PyObject * obj1 = 0 ;
39873 PyObject * obj2 = 0 ;
39874 char *kwnames[] = {
39875 (char *) "self",(char *) "item",(char *) "size", NULL
39876 };
39877
39878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39880 if (SWIG_arg_fail(1)) SWIG_fail;
39881 arg2 = obj1;
39882 {
39883 arg3 = &temp3;
39884 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39885 }
39886 {
39887 PyThreadState* __tstate = wxPyBeginAllowThreads();
39888 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39889
39890 wxPyEndAllowThreads(__tstate);
39891 if (PyErr_Occurred()) SWIG_fail;
39892 }
39893 Py_INCREF(Py_None); resultobj = Py_None;
39894 return resultobj;
39895 fail:
39896 return NULL;
39897 }
39898
39899
39900 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39901 PyObject *resultobj;
39902 wxSizer *arg1 = (wxSizer *) 0 ;
39903 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39904 wxSizerItem *result;
39905 PyObject * obj0 = 0 ;
39906 PyObject * obj1 = 0 ;
39907 char *kwnames[] = {
39908 (char *) "self",(char *) "item", NULL
39909 };
39910
39911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39913 if (SWIG_arg_fail(1)) SWIG_fail;
39914 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39915 if (SWIG_arg_fail(2)) SWIG_fail;
39916 {
39917 PyThreadState* __tstate = wxPyBeginAllowThreads();
39918 result = (wxSizerItem *)(arg1)->Add(arg2);
39919
39920 wxPyEndAllowThreads(__tstate);
39921 if (PyErr_Occurred()) SWIG_fail;
39922 }
39923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39924 return resultobj;
39925 fail:
39926 return NULL;
39927 }
39928
39929
39930 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39931 PyObject *resultobj;
39932 wxSizer *arg1 = (wxSizer *) 0 ;
39933 size_t arg2 ;
39934 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39935 wxSizerItem *result;
39936 PyObject * obj0 = 0 ;
39937 PyObject * obj1 = 0 ;
39938 PyObject * obj2 = 0 ;
39939 char *kwnames[] = {
39940 (char *) "self",(char *) "index",(char *) "item", NULL
39941 };
39942
39943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39945 if (SWIG_arg_fail(1)) SWIG_fail;
39946 {
39947 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39948 if (SWIG_arg_fail(2)) SWIG_fail;
39949 }
39950 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39951 if (SWIG_arg_fail(3)) SWIG_fail;
39952 {
39953 PyThreadState* __tstate = wxPyBeginAllowThreads();
39954 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39955
39956 wxPyEndAllowThreads(__tstate);
39957 if (PyErr_Occurred()) SWIG_fail;
39958 }
39959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39960 return resultobj;
39961 fail:
39962 return NULL;
39963 }
39964
39965
39966 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39967 PyObject *resultobj;
39968 wxSizer *arg1 = (wxSizer *) 0 ;
39969 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39970 wxSizerItem *result;
39971 PyObject * obj0 = 0 ;
39972 PyObject * obj1 = 0 ;
39973 char *kwnames[] = {
39974 (char *) "self",(char *) "item", NULL
39975 };
39976
39977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39979 if (SWIG_arg_fail(1)) SWIG_fail;
39980 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39981 if (SWIG_arg_fail(2)) SWIG_fail;
39982 {
39983 PyThreadState* __tstate = wxPyBeginAllowThreads();
39984 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39985
39986 wxPyEndAllowThreads(__tstate);
39987 if (PyErr_Occurred()) SWIG_fail;
39988 }
39989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39990 return resultobj;
39991 fail:
39992 return NULL;
39993 }
39994
39995
39996 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39997 PyObject *resultobj;
39998 wxSizer *arg1 = (wxSizer *) 0 ;
39999 int arg2 ;
40000 int arg3 ;
40001 int arg4 ;
40002 int arg5 ;
40003 PyObject * obj0 = 0 ;
40004 PyObject * obj1 = 0 ;
40005 PyObject * obj2 = 0 ;
40006 PyObject * obj3 = 0 ;
40007 PyObject * obj4 = 0 ;
40008 char *kwnames[] = {
40009 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40010 };
40011
40012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40014 if (SWIG_arg_fail(1)) SWIG_fail;
40015 {
40016 arg2 = (int)(SWIG_As_int(obj1));
40017 if (SWIG_arg_fail(2)) SWIG_fail;
40018 }
40019 {
40020 arg3 = (int)(SWIG_As_int(obj2));
40021 if (SWIG_arg_fail(3)) SWIG_fail;
40022 }
40023 {
40024 arg4 = (int)(SWIG_As_int(obj3));
40025 if (SWIG_arg_fail(4)) SWIG_fail;
40026 }
40027 {
40028 arg5 = (int)(SWIG_As_int(obj4));
40029 if (SWIG_arg_fail(5)) SWIG_fail;
40030 }
40031 {
40032 PyThreadState* __tstate = wxPyBeginAllowThreads();
40033 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40034
40035 wxPyEndAllowThreads(__tstate);
40036 if (PyErr_Occurred()) SWIG_fail;
40037 }
40038 Py_INCREF(Py_None); resultobj = Py_None;
40039 return resultobj;
40040 fail:
40041 return NULL;
40042 }
40043
40044
40045 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40046 PyObject *resultobj;
40047 wxSizer *arg1 = (wxSizer *) 0 ;
40048 wxSize *arg2 = 0 ;
40049 wxSize temp2 ;
40050 PyObject * obj0 = 0 ;
40051 PyObject * obj1 = 0 ;
40052 char *kwnames[] = {
40053 (char *) "self",(char *) "size", NULL
40054 };
40055
40056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40058 if (SWIG_arg_fail(1)) SWIG_fail;
40059 {
40060 arg2 = &temp2;
40061 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40062 }
40063 {
40064 PyThreadState* __tstate = wxPyBeginAllowThreads();
40065 (arg1)->SetMinSize((wxSize const &)*arg2);
40066
40067 wxPyEndAllowThreads(__tstate);
40068 if (PyErr_Occurred()) SWIG_fail;
40069 }
40070 Py_INCREF(Py_None); resultobj = Py_None;
40071 return resultobj;
40072 fail:
40073 return NULL;
40074 }
40075
40076
40077 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40078 PyObject *resultobj;
40079 wxSizer *arg1 = (wxSizer *) 0 ;
40080 wxSize result;
40081 PyObject * obj0 = 0 ;
40082 char *kwnames[] = {
40083 (char *) "self", NULL
40084 };
40085
40086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40088 if (SWIG_arg_fail(1)) SWIG_fail;
40089 {
40090 PyThreadState* __tstate = wxPyBeginAllowThreads();
40091 result = (arg1)->GetSize();
40092
40093 wxPyEndAllowThreads(__tstate);
40094 if (PyErr_Occurred()) SWIG_fail;
40095 }
40096 {
40097 wxSize * resultptr;
40098 resultptr = new wxSize((wxSize &)(result));
40099 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40100 }
40101 return resultobj;
40102 fail:
40103 return NULL;
40104 }
40105
40106
40107 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40108 PyObject *resultobj;
40109 wxSizer *arg1 = (wxSizer *) 0 ;
40110 wxPoint result;
40111 PyObject * obj0 = 0 ;
40112 char *kwnames[] = {
40113 (char *) "self", NULL
40114 };
40115
40116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40118 if (SWIG_arg_fail(1)) SWIG_fail;
40119 {
40120 PyThreadState* __tstate = wxPyBeginAllowThreads();
40121 result = (arg1)->GetPosition();
40122
40123 wxPyEndAllowThreads(__tstate);
40124 if (PyErr_Occurred()) SWIG_fail;
40125 }
40126 {
40127 wxPoint * resultptr;
40128 resultptr = new wxPoint((wxPoint &)(result));
40129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40130 }
40131 return resultobj;
40132 fail:
40133 return NULL;
40134 }
40135
40136
40137 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40138 PyObject *resultobj;
40139 wxSizer *arg1 = (wxSizer *) 0 ;
40140 wxSize result;
40141 PyObject * obj0 = 0 ;
40142 char *kwnames[] = {
40143 (char *) "self", NULL
40144 };
40145
40146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40148 if (SWIG_arg_fail(1)) SWIG_fail;
40149 {
40150 PyThreadState* __tstate = wxPyBeginAllowThreads();
40151 result = (arg1)->GetMinSize();
40152
40153 wxPyEndAllowThreads(__tstate);
40154 if (PyErr_Occurred()) SWIG_fail;
40155 }
40156 {
40157 wxSize * resultptr;
40158 resultptr = new wxSize((wxSize &)(result));
40159 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40160 }
40161 return resultobj;
40162 fail:
40163 return NULL;
40164 }
40165
40166
40167 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40168 PyObject *resultobj;
40169 wxSizer *arg1 = (wxSizer *) 0 ;
40170 PyObject * obj0 = 0 ;
40171 char *kwnames[] = {
40172 (char *) "self", NULL
40173 };
40174
40175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40177 if (SWIG_arg_fail(1)) SWIG_fail;
40178 {
40179 PyThreadState* __tstate = wxPyBeginAllowThreads();
40180 (arg1)->RecalcSizes();
40181
40182 wxPyEndAllowThreads(__tstate);
40183 if (PyErr_Occurred()) SWIG_fail;
40184 }
40185 Py_INCREF(Py_None); resultobj = Py_None;
40186 return resultobj;
40187 fail:
40188 return NULL;
40189 }
40190
40191
40192 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40193 PyObject *resultobj;
40194 wxSizer *arg1 = (wxSizer *) 0 ;
40195 wxSize result;
40196 PyObject * obj0 = 0 ;
40197 char *kwnames[] = {
40198 (char *) "self", NULL
40199 };
40200
40201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40203 if (SWIG_arg_fail(1)) SWIG_fail;
40204 {
40205 PyThreadState* __tstate = wxPyBeginAllowThreads();
40206 result = (arg1)->CalcMin();
40207
40208 wxPyEndAllowThreads(__tstate);
40209 if (PyErr_Occurred()) SWIG_fail;
40210 }
40211 {
40212 wxSize * resultptr;
40213 resultptr = new wxSize((wxSize &)(result));
40214 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40215 }
40216 return resultobj;
40217 fail:
40218 return NULL;
40219 }
40220
40221
40222 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40223 PyObject *resultobj;
40224 wxSizer *arg1 = (wxSizer *) 0 ;
40225 PyObject * obj0 = 0 ;
40226 char *kwnames[] = {
40227 (char *) "self", NULL
40228 };
40229
40230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40232 if (SWIG_arg_fail(1)) SWIG_fail;
40233 {
40234 PyThreadState* __tstate = wxPyBeginAllowThreads();
40235 (arg1)->Layout();
40236
40237 wxPyEndAllowThreads(__tstate);
40238 if (PyErr_Occurred()) SWIG_fail;
40239 }
40240 Py_INCREF(Py_None); resultobj = Py_None;
40241 return resultobj;
40242 fail:
40243 return NULL;
40244 }
40245
40246
40247 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40248 PyObject *resultobj;
40249 wxSizer *arg1 = (wxSizer *) 0 ;
40250 wxWindow *arg2 = (wxWindow *) 0 ;
40251 wxSize result;
40252 PyObject * obj0 = 0 ;
40253 PyObject * obj1 = 0 ;
40254 char *kwnames[] = {
40255 (char *) "self",(char *) "window", NULL
40256 };
40257
40258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40260 if (SWIG_arg_fail(1)) SWIG_fail;
40261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40262 if (SWIG_arg_fail(2)) SWIG_fail;
40263 {
40264 PyThreadState* __tstate = wxPyBeginAllowThreads();
40265 result = (arg1)->Fit(arg2);
40266
40267 wxPyEndAllowThreads(__tstate);
40268 if (PyErr_Occurred()) SWIG_fail;
40269 }
40270 {
40271 wxSize * resultptr;
40272 resultptr = new wxSize((wxSize &)(result));
40273 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40274 }
40275 return resultobj;
40276 fail:
40277 return NULL;
40278 }
40279
40280
40281 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40282 PyObject *resultobj;
40283 wxSizer *arg1 = (wxSizer *) 0 ;
40284 wxWindow *arg2 = (wxWindow *) 0 ;
40285 PyObject * obj0 = 0 ;
40286 PyObject * obj1 = 0 ;
40287 char *kwnames[] = {
40288 (char *) "self",(char *) "window", NULL
40289 };
40290
40291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40293 if (SWIG_arg_fail(1)) SWIG_fail;
40294 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40295 if (SWIG_arg_fail(2)) SWIG_fail;
40296 {
40297 PyThreadState* __tstate = wxPyBeginAllowThreads();
40298 (arg1)->FitInside(arg2);
40299
40300 wxPyEndAllowThreads(__tstate);
40301 if (PyErr_Occurred()) SWIG_fail;
40302 }
40303 Py_INCREF(Py_None); resultobj = Py_None;
40304 return resultobj;
40305 fail:
40306 return NULL;
40307 }
40308
40309
40310 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40311 PyObject *resultobj;
40312 wxSizer *arg1 = (wxSizer *) 0 ;
40313 wxWindow *arg2 = (wxWindow *) 0 ;
40314 PyObject * obj0 = 0 ;
40315 PyObject * obj1 = 0 ;
40316 char *kwnames[] = {
40317 (char *) "self",(char *) "window", NULL
40318 };
40319
40320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40322 if (SWIG_arg_fail(1)) SWIG_fail;
40323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40324 if (SWIG_arg_fail(2)) SWIG_fail;
40325 {
40326 PyThreadState* __tstate = wxPyBeginAllowThreads();
40327 (arg1)->SetSizeHints(arg2);
40328
40329 wxPyEndAllowThreads(__tstate);
40330 if (PyErr_Occurred()) SWIG_fail;
40331 }
40332 Py_INCREF(Py_None); resultobj = Py_None;
40333 return resultobj;
40334 fail:
40335 return NULL;
40336 }
40337
40338
40339 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40340 PyObject *resultobj;
40341 wxSizer *arg1 = (wxSizer *) 0 ;
40342 wxWindow *arg2 = (wxWindow *) 0 ;
40343 PyObject * obj0 = 0 ;
40344 PyObject * obj1 = 0 ;
40345 char *kwnames[] = {
40346 (char *) "self",(char *) "window", NULL
40347 };
40348
40349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40351 if (SWIG_arg_fail(1)) SWIG_fail;
40352 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40353 if (SWIG_arg_fail(2)) SWIG_fail;
40354 {
40355 PyThreadState* __tstate = wxPyBeginAllowThreads();
40356 (arg1)->SetVirtualSizeHints(arg2);
40357
40358 wxPyEndAllowThreads(__tstate);
40359 if (PyErr_Occurred()) SWIG_fail;
40360 }
40361 Py_INCREF(Py_None); resultobj = Py_None;
40362 return resultobj;
40363 fail:
40364 return NULL;
40365 }
40366
40367
40368 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40369 PyObject *resultobj;
40370 wxSizer *arg1 = (wxSizer *) 0 ;
40371 bool arg2 = (bool) false ;
40372 PyObject * obj0 = 0 ;
40373 PyObject * obj1 = 0 ;
40374 char *kwnames[] = {
40375 (char *) "self",(char *) "deleteWindows", NULL
40376 };
40377
40378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40380 if (SWIG_arg_fail(1)) SWIG_fail;
40381 if (obj1) {
40382 {
40383 arg2 = (bool)(SWIG_As_bool(obj1));
40384 if (SWIG_arg_fail(2)) SWIG_fail;
40385 }
40386 }
40387 {
40388 PyThreadState* __tstate = wxPyBeginAllowThreads();
40389 (arg1)->Clear(arg2);
40390
40391 wxPyEndAllowThreads(__tstate);
40392 if (PyErr_Occurred()) SWIG_fail;
40393 }
40394 Py_INCREF(Py_None); resultobj = Py_None;
40395 return resultobj;
40396 fail:
40397 return NULL;
40398 }
40399
40400
40401 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40402 PyObject *resultobj;
40403 wxSizer *arg1 = (wxSizer *) 0 ;
40404 PyObject * obj0 = 0 ;
40405 char *kwnames[] = {
40406 (char *) "self", NULL
40407 };
40408
40409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40411 if (SWIG_arg_fail(1)) SWIG_fail;
40412 {
40413 PyThreadState* __tstate = wxPyBeginAllowThreads();
40414 (arg1)->DeleteWindows();
40415
40416 wxPyEndAllowThreads(__tstate);
40417 if (PyErr_Occurred()) SWIG_fail;
40418 }
40419 Py_INCREF(Py_None); resultobj = Py_None;
40420 return resultobj;
40421 fail:
40422 return NULL;
40423 }
40424
40425
40426 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40427 PyObject *resultobj;
40428 wxSizer *arg1 = (wxSizer *) 0 ;
40429 PyObject *result;
40430 PyObject * obj0 = 0 ;
40431 char *kwnames[] = {
40432 (char *) "self", NULL
40433 };
40434
40435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40437 if (SWIG_arg_fail(1)) SWIG_fail;
40438 {
40439 PyThreadState* __tstate = wxPyBeginAllowThreads();
40440 result = (PyObject *)wxSizer_GetChildren(arg1);
40441
40442 wxPyEndAllowThreads(__tstate);
40443 if (PyErr_Occurred()) SWIG_fail;
40444 }
40445 resultobj = result;
40446 return resultobj;
40447 fail:
40448 return NULL;
40449 }
40450
40451
40452 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40453 PyObject *resultobj;
40454 wxSizer *arg1 = (wxSizer *) 0 ;
40455 PyObject *arg2 = (PyObject *) 0 ;
40456 bool arg3 = (bool) true ;
40457 bool arg4 = (bool) false ;
40458 bool result;
40459 PyObject * obj0 = 0 ;
40460 PyObject * obj1 = 0 ;
40461 PyObject * obj2 = 0 ;
40462 PyObject * obj3 = 0 ;
40463 char *kwnames[] = {
40464 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40465 };
40466
40467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40469 if (SWIG_arg_fail(1)) SWIG_fail;
40470 arg2 = obj1;
40471 if (obj2) {
40472 {
40473 arg3 = (bool)(SWIG_As_bool(obj2));
40474 if (SWIG_arg_fail(3)) SWIG_fail;
40475 }
40476 }
40477 if (obj3) {
40478 {
40479 arg4 = (bool)(SWIG_As_bool(obj3));
40480 if (SWIG_arg_fail(4)) SWIG_fail;
40481 }
40482 }
40483 {
40484 PyThreadState* __tstate = wxPyBeginAllowThreads();
40485 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40486
40487 wxPyEndAllowThreads(__tstate);
40488 if (PyErr_Occurred()) SWIG_fail;
40489 }
40490 {
40491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40492 }
40493 return resultobj;
40494 fail:
40495 return NULL;
40496 }
40497
40498
40499 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40500 PyObject *resultobj;
40501 wxSizer *arg1 = (wxSizer *) 0 ;
40502 PyObject *arg2 = (PyObject *) 0 ;
40503 bool result;
40504 PyObject * obj0 = 0 ;
40505 PyObject * obj1 = 0 ;
40506 char *kwnames[] = {
40507 (char *) "self",(char *) "item", NULL
40508 };
40509
40510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40512 if (SWIG_arg_fail(1)) SWIG_fail;
40513 arg2 = obj1;
40514 {
40515 PyThreadState* __tstate = wxPyBeginAllowThreads();
40516 result = (bool)wxSizer_IsShown(arg1,arg2);
40517
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 {
40522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40523 }
40524 return resultobj;
40525 fail:
40526 return NULL;
40527 }
40528
40529
40530 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40531 PyObject *resultobj;
40532 wxSizer *arg1 = (wxSizer *) 0 ;
40533 bool arg2 ;
40534 PyObject * obj0 = 0 ;
40535 PyObject * obj1 = 0 ;
40536 char *kwnames[] = {
40537 (char *) "self",(char *) "show", NULL
40538 };
40539
40540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40542 if (SWIG_arg_fail(1)) SWIG_fail;
40543 {
40544 arg2 = (bool)(SWIG_As_bool(obj1));
40545 if (SWIG_arg_fail(2)) SWIG_fail;
40546 }
40547 {
40548 PyThreadState* __tstate = wxPyBeginAllowThreads();
40549 (arg1)->ShowItems(arg2);
40550
40551 wxPyEndAllowThreads(__tstate);
40552 if (PyErr_Occurred()) SWIG_fail;
40553 }
40554 Py_INCREF(Py_None); resultobj = Py_None;
40555 return resultobj;
40556 fail:
40557 return NULL;
40558 }
40559
40560
40561 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40562 PyObject *obj;
40563 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40564 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40565 Py_INCREF(obj);
40566 return Py_BuildValue((char *)"");
40567 }
40568 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40569 PyObject *resultobj;
40570 wxPySizer *result;
40571 char *kwnames[] = {
40572 NULL
40573 };
40574
40575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40576 {
40577 PyThreadState* __tstate = wxPyBeginAllowThreads();
40578 result = (wxPySizer *)new wxPySizer();
40579
40580 wxPyEndAllowThreads(__tstate);
40581 if (PyErr_Occurred()) SWIG_fail;
40582 }
40583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40584 return resultobj;
40585 fail:
40586 return NULL;
40587 }
40588
40589
40590 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40591 PyObject *resultobj;
40592 wxPySizer *arg1 = (wxPySizer *) 0 ;
40593 PyObject *arg2 = (PyObject *) 0 ;
40594 PyObject *arg3 = (PyObject *) 0 ;
40595 PyObject * obj0 = 0 ;
40596 PyObject * obj1 = 0 ;
40597 PyObject * obj2 = 0 ;
40598 char *kwnames[] = {
40599 (char *) "self",(char *) "self",(char *) "_class", NULL
40600 };
40601
40602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40604 if (SWIG_arg_fail(1)) SWIG_fail;
40605 arg2 = obj1;
40606 arg3 = obj2;
40607 {
40608 PyThreadState* __tstate = wxPyBeginAllowThreads();
40609 (arg1)->_setCallbackInfo(arg2,arg3);
40610
40611 wxPyEndAllowThreads(__tstate);
40612 if (PyErr_Occurred()) SWIG_fail;
40613 }
40614 Py_INCREF(Py_None); resultobj = Py_None;
40615 return resultobj;
40616 fail:
40617 return NULL;
40618 }
40619
40620
40621 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40622 PyObject *obj;
40623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40624 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40625 Py_INCREF(obj);
40626 return Py_BuildValue((char *)"");
40627 }
40628 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40629 PyObject *resultobj;
40630 int arg1 = (int) wxHORIZONTAL ;
40631 wxBoxSizer *result;
40632 PyObject * obj0 = 0 ;
40633 char *kwnames[] = {
40634 (char *) "orient", NULL
40635 };
40636
40637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40638 if (obj0) {
40639 {
40640 arg1 = (int)(SWIG_As_int(obj0));
40641 if (SWIG_arg_fail(1)) SWIG_fail;
40642 }
40643 }
40644 {
40645 PyThreadState* __tstate = wxPyBeginAllowThreads();
40646 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40647
40648 wxPyEndAllowThreads(__tstate);
40649 if (PyErr_Occurred()) SWIG_fail;
40650 }
40651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40652 return resultobj;
40653 fail:
40654 return NULL;
40655 }
40656
40657
40658 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40659 PyObject *resultobj;
40660 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40661 int result;
40662 PyObject * obj0 = 0 ;
40663 char *kwnames[] = {
40664 (char *) "self", NULL
40665 };
40666
40667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40669 if (SWIG_arg_fail(1)) SWIG_fail;
40670 {
40671 PyThreadState* __tstate = wxPyBeginAllowThreads();
40672 result = (int)(arg1)->GetOrientation();
40673
40674 wxPyEndAllowThreads(__tstate);
40675 if (PyErr_Occurred()) SWIG_fail;
40676 }
40677 {
40678 resultobj = SWIG_From_int((int)(result));
40679 }
40680 return resultobj;
40681 fail:
40682 return NULL;
40683 }
40684
40685
40686 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40687 PyObject *resultobj;
40688 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40689 int arg2 ;
40690 PyObject * obj0 = 0 ;
40691 PyObject * obj1 = 0 ;
40692 char *kwnames[] = {
40693 (char *) "self",(char *) "orient", NULL
40694 };
40695
40696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40698 if (SWIG_arg_fail(1)) SWIG_fail;
40699 {
40700 arg2 = (int)(SWIG_As_int(obj1));
40701 if (SWIG_arg_fail(2)) SWIG_fail;
40702 }
40703 {
40704 PyThreadState* __tstate = wxPyBeginAllowThreads();
40705 (arg1)->SetOrientation(arg2);
40706
40707 wxPyEndAllowThreads(__tstate);
40708 if (PyErr_Occurred()) SWIG_fail;
40709 }
40710 Py_INCREF(Py_None); resultobj = Py_None;
40711 return resultobj;
40712 fail:
40713 return NULL;
40714 }
40715
40716
40717 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40718 PyObject *obj;
40719 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40720 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40721 Py_INCREF(obj);
40722 return Py_BuildValue((char *)"");
40723 }
40724 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40725 PyObject *resultobj;
40726 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40727 int arg2 = (int) wxHORIZONTAL ;
40728 wxStaticBoxSizer *result;
40729 PyObject * obj0 = 0 ;
40730 PyObject * obj1 = 0 ;
40731 char *kwnames[] = {
40732 (char *) "box",(char *) "orient", NULL
40733 };
40734
40735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40737 if (SWIG_arg_fail(1)) SWIG_fail;
40738 if (obj1) {
40739 {
40740 arg2 = (int)(SWIG_As_int(obj1));
40741 if (SWIG_arg_fail(2)) SWIG_fail;
40742 }
40743 }
40744 {
40745 PyThreadState* __tstate = wxPyBeginAllowThreads();
40746 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40747
40748 wxPyEndAllowThreads(__tstate);
40749 if (PyErr_Occurred()) SWIG_fail;
40750 }
40751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40752 return resultobj;
40753 fail:
40754 return NULL;
40755 }
40756
40757
40758 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40759 PyObject *resultobj;
40760 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40761 wxStaticBox *result;
40762 PyObject * obj0 = 0 ;
40763 char *kwnames[] = {
40764 (char *) "self", NULL
40765 };
40766
40767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40769 if (SWIG_arg_fail(1)) SWIG_fail;
40770 {
40771 PyThreadState* __tstate = wxPyBeginAllowThreads();
40772 result = (wxStaticBox *)(arg1)->GetStaticBox();
40773
40774 wxPyEndAllowThreads(__tstate);
40775 if (PyErr_Occurred()) SWIG_fail;
40776 }
40777 {
40778 resultobj = wxPyMake_wxObject(result, 0);
40779 }
40780 return resultobj;
40781 fail:
40782 return NULL;
40783 }
40784
40785
40786 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40787 PyObject *obj;
40788 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40789 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40790 Py_INCREF(obj);
40791 return Py_BuildValue((char *)"");
40792 }
40793 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40794 PyObject *resultobj;
40795 int arg1 = (int) 1 ;
40796 int arg2 = (int) 0 ;
40797 int arg3 = (int) 0 ;
40798 int arg4 = (int) 0 ;
40799 wxGridSizer *result;
40800 PyObject * obj0 = 0 ;
40801 PyObject * obj1 = 0 ;
40802 PyObject * obj2 = 0 ;
40803 PyObject * obj3 = 0 ;
40804 char *kwnames[] = {
40805 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40806 };
40807
40808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40809 if (obj0) {
40810 {
40811 arg1 = (int)(SWIG_As_int(obj0));
40812 if (SWIG_arg_fail(1)) SWIG_fail;
40813 }
40814 }
40815 if (obj1) {
40816 {
40817 arg2 = (int)(SWIG_As_int(obj1));
40818 if (SWIG_arg_fail(2)) SWIG_fail;
40819 }
40820 }
40821 if (obj2) {
40822 {
40823 arg3 = (int)(SWIG_As_int(obj2));
40824 if (SWIG_arg_fail(3)) SWIG_fail;
40825 }
40826 }
40827 if (obj3) {
40828 {
40829 arg4 = (int)(SWIG_As_int(obj3));
40830 if (SWIG_arg_fail(4)) SWIG_fail;
40831 }
40832 }
40833 {
40834 PyThreadState* __tstate = wxPyBeginAllowThreads();
40835 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40836
40837 wxPyEndAllowThreads(__tstate);
40838 if (PyErr_Occurred()) SWIG_fail;
40839 }
40840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40841 return resultobj;
40842 fail:
40843 return NULL;
40844 }
40845
40846
40847 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40848 PyObject *resultobj;
40849 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40850 int arg2 ;
40851 PyObject * obj0 = 0 ;
40852 PyObject * obj1 = 0 ;
40853 char *kwnames[] = {
40854 (char *) "self",(char *) "cols", NULL
40855 };
40856
40857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40859 if (SWIG_arg_fail(1)) SWIG_fail;
40860 {
40861 arg2 = (int)(SWIG_As_int(obj1));
40862 if (SWIG_arg_fail(2)) SWIG_fail;
40863 }
40864 {
40865 PyThreadState* __tstate = wxPyBeginAllowThreads();
40866 (arg1)->SetCols(arg2);
40867
40868 wxPyEndAllowThreads(__tstate);
40869 if (PyErr_Occurred()) SWIG_fail;
40870 }
40871 Py_INCREF(Py_None); resultobj = Py_None;
40872 return resultobj;
40873 fail:
40874 return NULL;
40875 }
40876
40877
40878 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40879 PyObject *resultobj;
40880 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40881 int arg2 ;
40882 PyObject * obj0 = 0 ;
40883 PyObject * obj1 = 0 ;
40884 char *kwnames[] = {
40885 (char *) "self",(char *) "rows", NULL
40886 };
40887
40888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40890 if (SWIG_arg_fail(1)) SWIG_fail;
40891 {
40892 arg2 = (int)(SWIG_As_int(obj1));
40893 if (SWIG_arg_fail(2)) SWIG_fail;
40894 }
40895 {
40896 PyThreadState* __tstate = wxPyBeginAllowThreads();
40897 (arg1)->SetRows(arg2);
40898
40899 wxPyEndAllowThreads(__tstate);
40900 if (PyErr_Occurred()) SWIG_fail;
40901 }
40902 Py_INCREF(Py_None); resultobj = Py_None;
40903 return resultobj;
40904 fail:
40905 return NULL;
40906 }
40907
40908
40909 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40910 PyObject *resultobj;
40911 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40912 int arg2 ;
40913 PyObject * obj0 = 0 ;
40914 PyObject * obj1 = 0 ;
40915 char *kwnames[] = {
40916 (char *) "self",(char *) "gap", NULL
40917 };
40918
40919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40921 if (SWIG_arg_fail(1)) SWIG_fail;
40922 {
40923 arg2 = (int)(SWIG_As_int(obj1));
40924 if (SWIG_arg_fail(2)) SWIG_fail;
40925 }
40926 {
40927 PyThreadState* __tstate = wxPyBeginAllowThreads();
40928 (arg1)->SetVGap(arg2);
40929
40930 wxPyEndAllowThreads(__tstate);
40931 if (PyErr_Occurred()) SWIG_fail;
40932 }
40933 Py_INCREF(Py_None); resultobj = Py_None;
40934 return resultobj;
40935 fail:
40936 return NULL;
40937 }
40938
40939
40940 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40941 PyObject *resultobj;
40942 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40943 int arg2 ;
40944 PyObject * obj0 = 0 ;
40945 PyObject * obj1 = 0 ;
40946 char *kwnames[] = {
40947 (char *) "self",(char *) "gap", NULL
40948 };
40949
40950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40952 if (SWIG_arg_fail(1)) SWIG_fail;
40953 {
40954 arg2 = (int)(SWIG_As_int(obj1));
40955 if (SWIG_arg_fail(2)) SWIG_fail;
40956 }
40957 {
40958 PyThreadState* __tstate = wxPyBeginAllowThreads();
40959 (arg1)->SetHGap(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_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40972 PyObject *resultobj;
40973 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40974 int result;
40975 PyObject * obj0 = 0 ;
40976 char *kwnames[] = {
40977 (char *) "self", NULL
40978 };
40979
40980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40982 if (SWIG_arg_fail(1)) SWIG_fail;
40983 {
40984 PyThreadState* __tstate = wxPyBeginAllowThreads();
40985 result = (int)(arg1)->GetCols();
40986
40987 wxPyEndAllowThreads(__tstate);
40988 if (PyErr_Occurred()) SWIG_fail;
40989 }
40990 {
40991 resultobj = SWIG_From_int((int)(result));
40992 }
40993 return resultobj;
40994 fail:
40995 return NULL;
40996 }
40997
40998
40999 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41000 PyObject *resultobj;
41001 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41002 int result;
41003 PyObject * obj0 = 0 ;
41004 char *kwnames[] = {
41005 (char *) "self", NULL
41006 };
41007
41008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41010 if (SWIG_arg_fail(1)) SWIG_fail;
41011 {
41012 PyThreadState* __tstate = wxPyBeginAllowThreads();
41013 result = (int)(arg1)->GetRows();
41014
41015 wxPyEndAllowThreads(__tstate);
41016 if (PyErr_Occurred()) SWIG_fail;
41017 }
41018 {
41019 resultobj = SWIG_From_int((int)(result));
41020 }
41021 return resultobj;
41022 fail:
41023 return NULL;
41024 }
41025
41026
41027 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41028 PyObject *resultobj;
41029 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41030 int result;
41031 PyObject * obj0 = 0 ;
41032 char *kwnames[] = {
41033 (char *) "self", NULL
41034 };
41035
41036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41038 if (SWIG_arg_fail(1)) SWIG_fail;
41039 {
41040 PyThreadState* __tstate = wxPyBeginAllowThreads();
41041 result = (int)(arg1)->GetVGap();
41042
41043 wxPyEndAllowThreads(__tstate);
41044 if (PyErr_Occurred()) SWIG_fail;
41045 }
41046 {
41047 resultobj = SWIG_From_int((int)(result));
41048 }
41049 return resultobj;
41050 fail:
41051 return NULL;
41052 }
41053
41054
41055 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41056 PyObject *resultobj;
41057 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41058 int result;
41059 PyObject * obj0 = 0 ;
41060 char *kwnames[] = {
41061 (char *) "self", NULL
41062 };
41063
41064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41066 if (SWIG_arg_fail(1)) SWIG_fail;
41067 {
41068 PyThreadState* __tstate = wxPyBeginAllowThreads();
41069 result = (int)(arg1)->GetHGap();
41070
41071 wxPyEndAllowThreads(__tstate);
41072 if (PyErr_Occurred()) SWIG_fail;
41073 }
41074 {
41075 resultobj = SWIG_From_int((int)(result));
41076 }
41077 return resultobj;
41078 fail:
41079 return NULL;
41080 }
41081
41082
41083 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41084 PyObject *obj;
41085 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41086 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41087 Py_INCREF(obj);
41088 return Py_BuildValue((char *)"");
41089 }
41090 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41091 PyObject *resultobj;
41092 int arg1 = (int) 1 ;
41093 int arg2 = (int) 0 ;
41094 int arg3 = (int) 0 ;
41095 int arg4 = (int) 0 ;
41096 wxFlexGridSizer *result;
41097 PyObject * obj0 = 0 ;
41098 PyObject * obj1 = 0 ;
41099 PyObject * obj2 = 0 ;
41100 PyObject * obj3 = 0 ;
41101 char *kwnames[] = {
41102 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41103 };
41104
41105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41106 if (obj0) {
41107 {
41108 arg1 = (int)(SWIG_As_int(obj0));
41109 if (SWIG_arg_fail(1)) SWIG_fail;
41110 }
41111 }
41112 if (obj1) {
41113 {
41114 arg2 = (int)(SWIG_As_int(obj1));
41115 if (SWIG_arg_fail(2)) SWIG_fail;
41116 }
41117 }
41118 if (obj2) {
41119 {
41120 arg3 = (int)(SWIG_As_int(obj2));
41121 if (SWIG_arg_fail(3)) SWIG_fail;
41122 }
41123 }
41124 if (obj3) {
41125 {
41126 arg4 = (int)(SWIG_As_int(obj3));
41127 if (SWIG_arg_fail(4)) SWIG_fail;
41128 }
41129 }
41130 {
41131 PyThreadState* __tstate = wxPyBeginAllowThreads();
41132 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41133
41134 wxPyEndAllowThreads(__tstate);
41135 if (PyErr_Occurred()) SWIG_fail;
41136 }
41137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41138 return resultobj;
41139 fail:
41140 return NULL;
41141 }
41142
41143
41144 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41145 PyObject *resultobj;
41146 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41147 size_t arg2 ;
41148 int arg3 = (int) 0 ;
41149 PyObject * obj0 = 0 ;
41150 PyObject * obj1 = 0 ;
41151 PyObject * obj2 = 0 ;
41152 char *kwnames[] = {
41153 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41154 };
41155
41156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41158 if (SWIG_arg_fail(1)) SWIG_fail;
41159 {
41160 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41161 if (SWIG_arg_fail(2)) SWIG_fail;
41162 }
41163 if (obj2) {
41164 {
41165 arg3 = (int)(SWIG_As_int(obj2));
41166 if (SWIG_arg_fail(3)) SWIG_fail;
41167 }
41168 }
41169 {
41170 PyThreadState* __tstate = wxPyBeginAllowThreads();
41171 (arg1)->AddGrowableRow(arg2,arg3);
41172
41173 wxPyEndAllowThreads(__tstate);
41174 if (PyErr_Occurred()) SWIG_fail;
41175 }
41176 Py_INCREF(Py_None); resultobj = Py_None;
41177 return resultobj;
41178 fail:
41179 return NULL;
41180 }
41181
41182
41183 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41184 PyObject *resultobj;
41185 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41186 size_t arg2 ;
41187 PyObject * obj0 = 0 ;
41188 PyObject * obj1 = 0 ;
41189 char *kwnames[] = {
41190 (char *) "self",(char *) "idx", NULL
41191 };
41192
41193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41195 if (SWIG_arg_fail(1)) SWIG_fail;
41196 {
41197 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41198 if (SWIG_arg_fail(2)) SWIG_fail;
41199 }
41200 {
41201 PyThreadState* __tstate = wxPyBeginAllowThreads();
41202 (arg1)->RemoveGrowableRow(arg2);
41203
41204 wxPyEndAllowThreads(__tstate);
41205 if (PyErr_Occurred()) SWIG_fail;
41206 }
41207 Py_INCREF(Py_None); resultobj = Py_None;
41208 return resultobj;
41209 fail:
41210 return NULL;
41211 }
41212
41213
41214 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41215 PyObject *resultobj;
41216 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41217 size_t arg2 ;
41218 int arg3 = (int) 0 ;
41219 PyObject * obj0 = 0 ;
41220 PyObject * obj1 = 0 ;
41221 PyObject * obj2 = 0 ;
41222 char *kwnames[] = {
41223 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41224 };
41225
41226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41228 if (SWIG_arg_fail(1)) SWIG_fail;
41229 {
41230 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41231 if (SWIG_arg_fail(2)) SWIG_fail;
41232 }
41233 if (obj2) {
41234 {
41235 arg3 = (int)(SWIG_As_int(obj2));
41236 if (SWIG_arg_fail(3)) SWIG_fail;
41237 }
41238 }
41239 {
41240 PyThreadState* __tstate = wxPyBeginAllowThreads();
41241 (arg1)->AddGrowableCol(arg2,arg3);
41242
41243 wxPyEndAllowThreads(__tstate);
41244 if (PyErr_Occurred()) SWIG_fail;
41245 }
41246 Py_INCREF(Py_None); resultobj = Py_None;
41247 return resultobj;
41248 fail:
41249 return NULL;
41250 }
41251
41252
41253 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41254 PyObject *resultobj;
41255 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41256 size_t arg2 ;
41257 PyObject * obj0 = 0 ;
41258 PyObject * obj1 = 0 ;
41259 char *kwnames[] = {
41260 (char *) "self",(char *) "idx", NULL
41261 };
41262
41263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41265 if (SWIG_arg_fail(1)) SWIG_fail;
41266 {
41267 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41268 if (SWIG_arg_fail(2)) SWIG_fail;
41269 }
41270 {
41271 PyThreadState* __tstate = wxPyBeginAllowThreads();
41272 (arg1)->RemoveGrowableCol(arg2);
41273
41274 wxPyEndAllowThreads(__tstate);
41275 if (PyErr_Occurred()) SWIG_fail;
41276 }
41277 Py_INCREF(Py_None); resultobj = Py_None;
41278 return resultobj;
41279 fail:
41280 return NULL;
41281 }
41282
41283
41284 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41285 PyObject *resultobj;
41286 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41287 int arg2 ;
41288 PyObject * obj0 = 0 ;
41289 PyObject * obj1 = 0 ;
41290 char *kwnames[] = {
41291 (char *) "self",(char *) "direction", NULL
41292 };
41293
41294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41296 if (SWIG_arg_fail(1)) SWIG_fail;
41297 {
41298 arg2 = (int)(SWIG_As_int(obj1));
41299 if (SWIG_arg_fail(2)) SWIG_fail;
41300 }
41301 {
41302 PyThreadState* __tstate = wxPyBeginAllowThreads();
41303 (arg1)->SetFlexibleDirection(arg2);
41304
41305 wxPyEndAllowThreads(__tstate);
41306 if (PyErr_Occurred()) SWIG_fail;
41307 }
41308 Py_INCREF(Py_None); resultobj = Py_None;
41309 return resultobj;
41310 fail:
41311 return NULL;
41312 }
41313
41314
41315 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41316 PyObject *resultobj;
41317 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41318 int result;
41319 PyObject * obj0 = 0 ;
41320 char *kwnames[] = {
41321 (char *) "self", NULL
41322 };
41323
41324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41326 if (SWIG_arg_fail(1)) SWIG_fail;
41327 {
41328 PyThreadState* __tstate = wxPyBeginAllowThreads();
41329 result = (int)(arg1)->GetFlexibleDirection();
41330
41331 wxPyEndAllowThreads(__tstate);
41332 if (PyErr_Occurred()) SWIG_fail;
41333 }
41334 {
41335 resultobj = SWIG_From_int((int)(result));
41336 }
41337 return resultobj;
41338 fail:
41339 return NULL;
41340 }
41341
41342
41343 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41344 PyObject *resultobj;
41345 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41346 wxFlexSizerGrowMode arg2 ;
41347 PyObject * obj0 = 0 ;
41348 PyObject * obj1 = 0 ;
41349 char *kwnames[] = {
41350 (char *) "self",(char *) "mode", NULL
41351 };
41352
41353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41355 if (SWIG_arg_fail(1)) SWIG_fail;
41356 {
41357 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41358 if (SWIG_arg_fail(2)) SWIG_fail;
41359 }
41360 {
41361 PyThreadState* __tstate = wxPyBeginAllowThreads();
41362 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41363
41364 wxPyEndAllowThreads(__tstate);
41365 if (PyErr_Occurred()) SWIG_fail;
41366 }
41367 Py_INCREF(Py_None); resultobj = Py_None;
41368 return resultobj;
41369 fail:
41370 return NULL;
41371 }
41372
41373
41374 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41375 PyObject *resultobj;
41376 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41377 wxFlexSizerGrowMode result;
41378 PyObject * obj0 = 0 ;
41379 char *kwnames[] = {
41380 (char *) "self", NULL
41381 };
41382
41383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41385 if (SWIG_arg_fail(1)) SWIG_fail;
41386 {
41387 PyThreadState* __tstate = wxPyBeginAllowThreads();
41388 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41389
41390 wxPyEndAllowThreads(__tstate);
41391 if (PyErr_Occurred()) SWIG_fail;
41392 }
41393 resultobj = SWIG_From_int((result));
41394 return resultobj;
41395 fail:
41396 return NULL;
41397 }
41398
41399
41400 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41401 PyObject *resultobj;
41402 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41403 wxArrayInt *result;
41404 PyObject * obj0 = 0 ;
41405 char *kwnames[] = {
41406 (char *) "self", NULL
41407 };
41408
41409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41411 if (SWIG_arg_fail(1)) SWIG_fail;
41412 {
41413 PyThreadState* __tstate = wxPyBeginAllowThreads();
41414 {
41415 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41416 result = (wxArrayInt *) &_result_ref;
41417 }
41418
41419 wxPyEndAllowThreads(__tstate);
41420 if (PyErr_Occurred()) SWIG_fail;
41421 }
41422 {
41423 resultobj = PyList_New(0);
41424 size_t idx;
41425 for (idx = 0; idx < result->GetCount(); idx += 1) {
41426 PyObject* val = PyInt_FromLong( result->Item(idx) );
41427 PyList_Append(resultobj, val);
41428 Py_DECREF(val);
41429 }
41430 }
41431 return resultobj;
41432 fail:
41433 return NULL;
41434 }
41435
41436
41437 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41438 PyObject *resultobj;
41439 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41440 wxArrayInt *result;
41441 PyObject * obj0 = 0 ;
41442 char *kwnames[] = {
41443 (char *) "self", NULL
41444 };
41445
41446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41448 if (SWIG_arg_fail(1)) SWIG_fail;
41449 {
41450 PyThreadState* __tstate = wxPyBeginAllowThreads();
41451 {
41452 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41453 result = (wxArrayInt *) &_result_ref;
41454 }
41455
41456 wxPyEndAllowThreads(__tstate);
41457 if (PyErr_Occurred()) SWIG_fail;
41458 }
41459 {
41460 resultobj = PyList_New(0);
41461 size_t idx;
41462 for (idx = 0; idx < result->GetCount(); idx += 1) {
41463 PyObject* val = PyInt_FromLong( result->Item(idx) );
41464 PyList_Append(resultobj, val);
41465 Py_DECREF(val);
41466 }
41467 }
41468 return resultobj;
41469 fail:
41470 return NULL;
41471 }
41472
41473
41474 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41475 PyObject *obj;
41476 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41477 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41478 Py_INCREF(obj);
41479 return Py_BuildValue((char *)"");
41480 }
41481 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41482 PyObject *resultobj;
41483 wxStdDialogButtonSizer *result;
41484 char *kwnames[] = {
41485 NULL
41486 };
41487
41488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41489 {
41490 PyThreadState* __tstate = wxPyBeginAllowThreads();
41491 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41492
41493 wxPyEndAllowThreads(__tstate);
41494 if (PyErr_Occurred()) SWIG_fail;
41495 }
41496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41497 return resultobj;
41498 fail:
41499 return NULL;
41500 }
41501
41502
41503 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41504 PyObject *resultobj;
41505 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41506 wxButton *arg2 = (wxButton *) 0 ;
41507 PyObject * obj0 = 0 ;
41508 PyObject * obj1 = 0 ;
41509 char *kwnames[] = {
41510 (char *) "self",(char *) "button", NULL
41511 };
41512
41513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41515 if (SWIG_arg_fail(1)) SWIG_fail;
41516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41517 if (SWIG_arg_fail(2)) SWIG_fail;
41518 {
41519 PyThreadState* __tstate = wxPyBeginAllowThreads();
41520 (arg1)->AddButton(arg2);
41521
41522 wxPyEndAllowThreads(__tstate);
41523 if (PyErr_Occurred()) SWIG_fail;
41524 }
41525 Py_INCREF(Py_None); resultobj = Py_None;
41526 return resultobj;
41527 fail:
41528 return NULL;
41529 }
41530
41531
41532 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41533 PyObject *resultobj;
41534 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41535 PyObject * obj0 = 0 ;
41536 char *kwnames[] = {
41537 (char *) "self", NULL
41538 };
41539
41540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41542 if (SWIG_arg_fail(1)) SWIG_fail;
41543 {
41544 PyThreadState* __tstate = wxPyBeginAllowThreads();
41545 (arg1)->Realize();
41546
41547 wxPyEndAllowThreads(__tstate);
41548 if (PyErr_Occurred()) SWIG_fail;
41549 }
41550 Py_INCREF(Py_None); resultobj = Py_None;
41551 return resultobj;
41552 fail:
41553 return NULL;
41554 }
41555
41556
41557 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41558 PyObject *resultobj;
41559 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41560 wxButton *arg2 = (wxButton *) 0 ;
41561 PyObject * obj0 = 0 ;
41562 PyObject * obj1 = 0 ;
41563 char *kwnames[] = {
41564 (char *) "self",(char *) "button", NULL
41565 };
41566
41567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41569 if (SWIG_arg_fail(1)) SWIG_fail;
41570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41571 if (SWIG_arg_fail(2)) SWIG_fail;
41572 {
41573 PyThreadState* __tstate = wxPyBeginAllowThreads();
41574 (arg1)->SetAffirmativeButton(arg2);
41575
41576 wxPyEndAllowThreads(__tstate);
41577 if (PyErr_Occurred()) SWIG_fail;
41578 }
41579 Py_INCREF(Py_None); resultobj = Py_None;
41580 return resultobj;
41581 fail:
41582 return NULL;
41583 }
41584
41585
41586 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41587 PyObject *resultobj;
41588 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41589 wxButton *arg2 = (wxButton *) 0 ;
41590 PyObject * obj0 = 0 ;
41591 PyObject * obj1 = 0 ;
41592 char *kwnames[] = {
41593 (char *) "self",(char *) "button", NULL
41594 };
41595
41596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41598 if (SWIG_arg_fail(1)) SWIG_fail;
41599 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41600 if (SWIG_arg_fail(2)) SWIG_fail;
41601 {
41602 PyThreadState* __tstate = wxPyBeginAllowThreads();
41603 (arg1)->SetNegativeButton(arg2);
41604
41605 wxPyEndAllowThreads(__tstate);
41606 if (PyErr_Occurred()) SWIG_fail;
41607 }
41608 Py_INCREF(Py_None); resultobj = Py_None;
41609 return resultobj;
41610 fail:
41611 return NULL;
41612 }
41613
41614
41615 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41616 PyObject *resultobj;
41617 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41618 wxButton *arg2 = (wxButton *) 0 ;
41619 PyObject * obj0 = 0 ;
41620 PyObject * obj1 = 0 ;
41621 char *kwnames[] = {
41622 (char *) "self",(char *) "button", NULL
41623 };
41624
41625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41627 if (SWIG_arg_fail(1)) SWIG_fail;
41628 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41629 if (SWIG_arg_fail(2)) SWIG_fail;
41630 {
41631 PyThreadState* __tstate = wxPyBeginAllowThreads();
41632 (arg1)->SetCancelButton(arg2);
41633
41634 wxPyEndAllowThreads(__tstate);
41635 if (PyErr_Occurred()) SWIG_fail;
41636 }
41637 Py_INCREF(Py_None); resultobj = Py_None;
41638 return resultobj;
41639 fail:
41640 return NULL;
41641 }
41642
41643
41644 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41645 PyObject *resultobj;
41646 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41647 wxButton *result;
41648 PyObject * obj0 = 0 ;
41649 char *kwnames[] = {
41650 (char *) "self", NULL
41651 };
41652
41653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41655 if (SWIG_arg_fail(1)) SWIG_fail;
41656 {
41657 PyThreadState* __tstate = wxPyBeginAllowThreads();
41658 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41659
41660 wxPyEndAllowThreads(__tstate);
41661 if (PyErr_Occurred()) SWIG_fail;
41662 }
41663 {
41664 resultobj = wxPyMake_wxObject(result, 0);
41665 }
41666 return resultobj;
41667 fail:
41668 return NULL;
41669 }
41670
41671
41672 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41673 PyObject *resultobj;
41674 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41675 wxButton *result;
41676 PyObject * obj0 = 0 ;
41677 char *kwnames[] = {
41678 (char *) "self", NULL
41679 };
41680
41681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41683 if (SWIG_arg_fail(1)) SWIG_fail;
41684 {
41685 PyThreadState* __tstate = wxPyBeginAllowThreads();
41686 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41687
41688 wxPyEndAllowThreads(__tstate);
41689 if (PyErr_Occurred()) SWIG_fail;
41690 }
41691 {
41692 resultobj = wxPyMake_wxObject(result, 0);
41693 }
41694 return resultobj;
41695 fail:
41696 return NULL;
41697 }
41698
41699
41700 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41701 PyObject *resultobj;
41702 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41703 wxButton *result;
41704 PyObject * obj0 = 0 ;
41705 char *kwnames[] = {
41706 (char *) "self", NULL
41707 };
41708
41709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41711 if (SWIG_arg_fail(1)) SWIG_fail;
41712 {
41713 PyThreadState* __tstate = wxPyBeginAllowThreads();
41714 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41715
41716 wxPyEndAllowThreads(__tstate);
41717 if (PyErr_Occurred()) SWIG_fail;
41718 }
41719 {
41720 resultobj = wxPyMake_wxObject(result, 0);
41721 }
41722 return resultobj;
41723 fail:
41724 return NULL;
41725 }
41726
41727
41728 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41729 PyObject *resultobj;
41730 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41731 wxButton *result;
41732 PyObject * obj0 = 0 ;
41733 char *kwnames[] = {
41734 (char *) "self", NULL
41735 };
41736
41737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41739 if (SWIG_arg_fail(1)) SWIG_fail;
41740 {
41741 PyThreadState* __tstate = wxPyBeginAllowThreads();
41742 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41743
41744 wxPyEndAllowThreads(__tstate);
41745 if (PyErr_Occurred()) SWIG_fail;
41746 }
41747 {
41748 resultobj = wxPyMake_wxObject(result, 0);
41749 }
41750 return resultobj;
41751 fail:
41752 return NULL;
41753 }
41754
41755
41756 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41757 PyObject *resultobj;
41758 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41759 wxButton *result;
41760 PyObject * obj0 = 0 ;
41761 char *kwnames[] = {
41762 (char *) "self", NULL
41763 };
41764
41765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41767 if (SWIG_arg_fail(1)) SWIG_fail;
41768 {
41769 PyThreadState* __tstate = wxPyBeginAllowThreads();
41770 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41771
41772 wxPyEndAllowThreads(__tstate);
41773 if (PyErr_Occurred()) SWIG_fail;
41774 }
41775 {
41776 resultobj = wxPyMake_wxObject(result, 0);
41777 }
41778 return resultobj;
41779 fail:
41780 return NULL;
41781 }
41782
41783
41784 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41785 PyObject *obj;
41786 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41787 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41788 Py_INCREF(obj);
41789 return Py_BuildValue((char *)"");
41790 }
41791 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41792 PyObject *resultobj;
41793 int arg1 = (int) 0 ;
41794 int arg2 = (int) 0 ;
41795 wxGBPosition *result;
41796 PyObject * obj0 = 0 ;
41797 PyObject * obj1 = 0 ;
41798 char *kwnames[] = {
41799 (char *) "row",(char *) "col", NULL
41800 };
41801
41802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41803 if (obj0) {
41804 {
41805 arg1 = (int)(SWIG_As_int(obj0));
41806 if (SWIG_arg_fail(1)) SWIG_fail;
41807 }
41808 }
41809 if (obj1) {
41810 {
41811 arg2 = (int)(SWIG_As_int(obj1));
41812 if (SWIG_arg_fail(2)) SWIG_fail;
41813 }
41814 }
41815 {
41816 PyThreadState* __tstate = wxPyBeginAllowThreads();
41817 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41818
41819 wxPyEndAllowThreads(__tstate);
41820 if (PyErr_Occurred()) SWIG_fail;
41821 }
41822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41823 return resultobj;
41824 fail:
41825 return NULL;
41826 }
41827
41828
41829 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41830 PyObject *resultobj;
41831 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41832 int result;
41833 PyObject * obj0 = 0 ;
41834 char *kwnames[] = {
41835 (char *) "self", NULL
41836 };
41837
41838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41840 if (SWIG_arg_fail(1)) SWIG_fail;
41841 {
41842 PyThreadState* __tstate = wxPyBeginAllowThreads();
41843 result = (int)((wxGBPosition const *)arg1)->GetRow();
41844
41845 wxPyEndAllowThreads(__tstate);
41846 if (PyErr_Occurred()) SWIG_fail;
41847 }
41848 {
41849 resultobj = SWIG_From_int((int)(result));
41850 }
41851 return resultobj;
41852 fail:
41853 return NULL;
41854 }
41855
41856
41857 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41858 PyObject *resultobj;
41859 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41860 int result;
41861 PyObject * obj0 = 0 ;
41862 char *kwnames[] = {
41863 (char *) "self", NULL
41864 };
41865
41866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41868 if (SWIG_arg_fail(1)) SWIG_fail;
41869 {
41870 PyThreadState* __tstate = wxPyBeginAllowThreads();
41871 result = (int)((wxGBPosition const *)arg1)->GetCol();
41872
41873 wxPyEndAllowThreads(__tstate);
41874 if (PyErr_Occurred()) SWIG_fail;
41875 }
41876 {
41877 resultobj = SWIG_From_int((int)(result));
41878 }
41879 return resultobj;
41880 fail:
41881 return NULL;
41882 }
41883
41884
41885 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41886 PyObject *resultobj;
41887 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41888 int arg2 ;
41889 PyObject * obj0 = 0 ;
41890 PyObject * obj1 = 0 ;
41891 char *kwnames[] = {
41892 (char *) "self",(char *) "row", NULL
41893 };
41894
41895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41897 if (SWIG_arg_fail(1)) SWIG_fail;
41898 {
41899 arg2 = (int)(SWIG_As_int(obj1));
41900 if (SWIG_arg_fail(2)) SWIG_fail;
41901 }
41902 {
41903 PyThreadState* __tstate = wxPyBeginAllowThreads();
41904 (arg1)->SetRow(arg2);
41905
41906 wxPyEndAllowThreads(__tstate);
41907 if (PyErr_Occurred()) SWIG_fail;
41908 }
41909 Py_INCREF(Py_None); resultobj = Py_None;
41910 return resultobj;
41911 fail:
41912 return NULL;
41913 }
41914
41915
41916 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41917 PyObject *resultobj;
41918 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41919 int arg2 ;
41920 PyObject * obj0 = 0 ;
41921 PyObject * obj1 = 0 ;
41922 char *kwnames[] = {
41923 (char *) "self",(char *) "col", NULL
41924 };
41925
41926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41928 if (SWIG_arg_fail(1)) SWIG_fail;
41929 {
41930 arg2 = (int)(SWIG_As_int(obj1));
41931 if (SWIG_arg_fail(2)) SWIG_fail;
41932 }
41933 {
41934 PyThreadState* __tstate = wxPyBeginAllowThreads();
41935 (arg1)->SetCol(arg2);
41936
41937 wxPyEndAllowThreads(__tstate);
41938 if (PyErr_Occurred()) SWIG_fail;
41939 }
41940 Py_INCREF(Py_None); resultobj = Py_None;
41941 return resultobj;
41942 fail:
41943 return NULL;
41944 }
41945
41946
41947 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41948 PyObject *resultobj;
41949 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41950 wxGBPosition *arg2 = 0 ;
41951 bool result;
41952 wxGBPosition temp2 ;
41953 PyObject * obj0 = 0 ;
41954 PyObject * obj1 = 0 ;
41955 char *kwnames[] = {
41956 (char *) "self",(char *) "other", NULL
41957 };
41958
41959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41961 if (SWIG_arg_fail(1)) SWIG_fail;
41962 {
41963 arg2 = &temp2;
41964 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41965 }
41966 {
41967 PyThreadState* __tstate = wxPyBeginAllowThreads();
41968 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41969
41970 wxPyEndAllowThreads(__tstate);
41971 if (PyErr_Occurred()) SWIG_fail;
41972 }
41973 {
41974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41975 }
41976 return resultobj;
41977 fail:
41978 return NULL;
41979 }
41980
41981
41982 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41983 PyObject *resultobj;
41984 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41985 wxGBPosition *arg2 = 0 ;
41986 bool result;
41987 wxGBPosition temp2 ;
41988 PyObject * obj0 = 0 ;
41989 PyObject * obj1 = 0 ;
41990 char *kwnames[] = {
41991 (char *) "self",(char *) "other", NULL
41992 };
41993
41994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41996 if (SWIG_arg_fail(1)) SWIG_fail;
41997 {
41998 arg2 = &temp2;
41999 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42000 }
42001 {
42002 PyThreadState* __tstate = wxPyBeginAllowThreads();
42003 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42004
42005 wxPyEndAllowThreads(__tstate);
42006 if (PyErr_Occurred()) SWIG_fail;
42007 }
42008 {
42009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42010 }
42011 return resultobj;
42012 fail:
42013 return NULL;
42014 }
42015
42016
42017 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42018 PyObject *resultobj;
42019 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42020 int arg2 = (int) 0 ;
42021 int arg3 = (int) 0 ;
42022 PyObject * obj0 = 0 ;
42023 PyObject * obj1 = 0 ;
42024 PyObject * obj2 = 0 ;
42025 char *kwnames[] = {
42026 (char *) "self",(char *) "row",(char *) "col", NULL
42027 };
42028
42029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42031 if (SWIG_arg_fail(1)) SWIG_fail;
42032 if (obj1) {
42033 {
42034 arg2 = (int)(SWIG_As_int(obj1));
42035 if (SWIG_arg_fail(2)) SWIG_fail;
42036 }
42037 }
42038 if (obj2) {
42039 {
42040 arg3 = (int)(SWIG_As_int(obj2));
42041 if (SWIG_arg_fail(3)) SWIG_fail;
42042 }
42043 }
42044 {
42045 PyThreadState* __tstate = wxPyBeginAllowThreads();
42046 wxGBPosition_Set(arg1,arg2,arg3);
42047
42048 wxPyEndAllowThreads(__tstate);
42049 if (PyErr_Occurred()) SWIG_fail;
42050 }
42051 Py_INCREF(Py_None); resultobj = Py_None;
42052 return resultobj;
42053 fail:
42054 return NULL;
42055 }
42056
42057
42058 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42059 PyObject *resultobj;
42060 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42061 PyObject *result;
42062 PyObject * obj0 = 0 ;
42063 char *kwnames[] = {
42064 (char *) "self", NULL
42065 };
42066
42067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42069 if (SWIG_arg_fail(1)) SWIG_fail;
42070 {
42071 PyThreadState* __tstate = wxPyBeginAllowThreads();
42072 result = (PyObject *)wxGBPosition_Get(arg1);
42073
42074 wxPyEndAllowThreads(__tstate);
42075 if (PyErr_Occurred()) SWIG_fail;
42076 }
42077 resultobj = result;
42078 return resultobj;
42079 fail:
42080 return NULL;
42081 }
42082
42083
42084 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42085 PyObject *obj;
42086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42087 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42088 Py_INCREF(obj);
42089 return Py_BuildValue((char *)"");
42090 }
42091 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42092 PyObject *resultobj;
42093 int arg1 = (int) 1 ;
42094 int arg2 = (int) 1 ;
42095 wxGBSpan *result;
42096 PyObject * obj0 = 0 ;
42097 PyObject * obj1 = 0 ;
42098 char *kwnames[] = {
42099 (char *) "rowspan",(char *) "colspan", NULL
42100 };
42101
42102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42103 if (obj0) {
42104 {
42105 arg1 = (int)(SWIG_As_int(obj0));
42106 if (SWIG_arg_fail(1)) SWIG_fail;
42107 }
42108 }
42109 if (obj1) {
42110 {
42111 arg2 = (int)(SWIG_As_int(obj1));
42112 if (SWIG_arg_fail(2)) SWIG_fail;
42113 }
42114 }
42115 {
42116 PyThreadState* __tstate = wxPyBeginAllowThreads();
42117 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42118
42119 wxPyEndAllowThreads(__tstate);
42120 if (PyErr_Occurred()) SWIG_fail;
42121 }
42122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42123 return resultobj;
42124 fail:
42125 return NULL;
42126 }
42127
42128
42129 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42130 PyObject *resultobj;
42131 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42132 int result;
42133 PyObject * obj0 = 0 ;
42134 char *kwnames[] = {
42135 (char *) "self", NULL
42136 };
42137
42138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42140 if (SWIG_arg_fail(1)) SWIG_fail;
42141 {
42142 PyThreadState* __tstate = wxPyBeginAllowThreads();
42143 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42144
42145 wxPyEndAllowThreads(__tstate);
42146 if (PyErr_Occurred()) SWIG_fail;
42147 }
42148 {
42149 resultobj = SWIG_From_int((int)(result));
42150 }
42151 return resultobj;
42152 fail:
42153 return NULL;
42154 }
42155
42156
42157 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42158 PyObject *resultobj;
42159 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42160 int result;
42161 PyObject * obj0 = 0 ;
42162 char *kwnames[] = {
42163 (char *) "self", NULL
42164 };
42165
42166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42168 if (SWIG_arg_fail(1)) SWIG_fail;
42169 {
42170 PyThreadState* __tstate = wxPyBeginAllowThreads();
42171 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42172
42173 wxPyEndAllowThreads(__tstate);
42174 if (PyErr_Occurred()) SWIG_fail;
42175 }
42176 {
42177 resultobj = SWIG_From_int((int)(result));
42178 }
42179 return resultobj;
42180 fail:
42181 return NULL;
42182 }
42183
42184
42185 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42186 PyObject *resultobj;
42187 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42188 int arg2 ;
42189 PyObject * obj0 = 0 ;
42190 PyObject * obj1 = 0 ;
42191 char *kwnames[] = {
42192 (char *) "self",(char *) "rowspan", NULL
42193 };
42194
42195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42197 if (SWIG_arg_fail(1)) SWIG_fail;
42198 {
42199 arg2 = (int)(SWIG_As_int(obj1));
42200 if (SWIG_arg_fail(2)) SWIG_fail;
42201 }
42202 {
42203 PyThreadState* __tstate = wxPyBeginAllowThreads();
42204 (arg1)->SetRowspan(arg2);
42205
42206 wxPyEndAllowThreads(__tstate);
42207 if (PyErr_Occurred()) SWIG_fail;
42208 }
42209 Py_INCREF(Py_None); resultobj = Py_None;
42210 return resultobj;
42211 fail:
42212 return NULL;
42213 }
42214
42215
42216 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42217 PyObject *resultobj;
42218 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42219 int arg2 ;
42220 PyObject * obj0 = 0 ;
42221 PyObject * obj1 = 0 ;
42222 char *kwnames[] = {
42223 (char *) "self",(char *) "colspan", NULL
42224 };
42225
42226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42228 if (SWIG_arg_fail(1)) SWIG_fail;
42229 {
42230 arg2 = (int)(SWIG_As_int(obj1));
42231 if (SWIG_arg_fail(2)) SWIG_fail;
42232 }
42233 {
42234 PyThreadState* __tstate = wxPyBeginAllowThreads();
42235 (arg1)->SetColspan(arg2);
42236
42237 wxPyEndAllowThreads(__tstate);
42238 if (PyErr_Occurred()) SWIG_fail;
42239 }
42240 Py_INCREF(Py_None); resultobj = Py_None;
42241 return resultobj;
42242 fail:
42243 return NULL;
42244 }
42245
42246
42247 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42248 PyObject *resultobj;
42249 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42250 wxGBSpan *arg2 = 0 ;
42251 bool result;
42252 wxGBSpan temp2 ;
42253 PyObject * obj0 = 0 ;
42254 PyObject * obj1 = 0 ;
42255 char *kwnames[] = {
42256 (char *) "self",(char *) "other", NULL
42257 };
42258
42259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42261 if (SWIG_arg_fail(1)) SWIG_fail;
42262 {
42263 arg2 = &temp2;
42264 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42265 }
42266 {
42267 PyThreadState* __tstate = wxPyBeginAllowThreads();
42268 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42269
42270 wxPyEndAllowThreads(__tstate);
42271 if (PyErr_Occurred()) SWIG_fail;
42272 }
42273 {
42274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42275 }
42276 return resultobj;
42277 fail:
42278 return NULL;
42279 }
42280
42281
42282 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42283 PyObject *resultobj;
42284 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42285 wxGBSpan *arg2 = 0 ;
42286 bool result;
42287 wxGBSpan temp2 ;
42288 PyObject * obj0 = 0 ;
42289 PyObject * obj1 = 0 ;
42290 char *kwnames[] = {
42291 (char *) "self",(char *) "other", NULL
42292 };
42293
42294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42296 if (SWIG_arg_fail(1)) SWIG_fail;
42297 {
42298 arg2 = &temp2;
42299 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42300 }
42301 {
42302 PyThreadState* __tstate = wxPyBeginAllowThreads();
42303 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42304
42305 wxPyEndAllowThreads(__tstate);
42306 if (PyErr_Occurred()) SWIG_fail;
42307 }
42308 {
42309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42310 }
42311 return resultobj;
42312 fail:
42313 return NULL;
42314 }
42315
42316
42317 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42318 PyObject *resultobj;
42319 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42320 int arg2 = (int) 1 ;
42321 int arg3 = (int) 1 ;
42322 PyObject * obj0 = 0 ;
42323 PyObject * obj1 = 0 ;
42324 PyObject * obj2 = 0 ;
42325 char *kwnames[] = {
42326 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42327 };
42328
42329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42331 if (SWIG_arg_fail(1)) SWIG_fail;
42332 if (obj1) {
42333 {
42334 arg2 = (int)(SWIG_As_int(obj1));
42335 if (SWIG_arg_fail(2)) SWIG_fail;
42336 }
42337 }
42338 if (obj2) {
42339 {
42340 arg3 = (int)(SWIG_As_int(obj2));
42341 if (SWIG_arg_fail(3)) SWIG_fail;
42342 }
42343 }
42344 {
42345 PyThreadState* __tstate = wxPyBeginAllowThreads();
42346 wxGBSpan_Set(arg1,arg2,arg3);
42347
42348 wxPyEndAllowThreads(__tstate);
42349 if (PyErr_Occurred()) SWIG_fail;
42350 }
42351 Py_INCREF(Py_None); resultobj = Py_None;
42352 return resultobj;
42353 fail:
42354 return NULL;
42355 }
42356
42357
42358 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42359 PyObject *resultobj;
42360 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42361 PyObject *result;
42362 PyObject * obj0 = 0 ;
42363 char *kwnames[] = {
42364 (char *) "self", NULL
42365 };
42366
42367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42369 if (SWIG_arg_fail(1)) SWIG_fail;
42370 {
42371 PyThreadState* __tstate = wxPyBeginAllowThreads();
42372 result = (PyObject *)wxGBSpan_Get(arg1);
42373
42374 wxPyEndAllowThreads(__tstate);
42375 if (PyErr_Occurred()) SWIG_fail;
42376 }
42377 resultobj = result;
42378 return resultobj;
42379 fail:
42380 return NULL;
42381 }
42382
42383
42384 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42385 PyObject *obj;
42386 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42387 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42388 Py_INCREF(obj);
42389 return Py_BuildValue((char *)"");
42390 }
42391 static int _wrap_DefaultSpan_set(PyObject *) {
42392 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42393 return 1;
42394 }
42395
42396
42397 static PyObject *_wrap_DefaultSpan_get(void) {
42398 PyObject *pyobj;
42399
42400 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42401 return pyobj;
42402 }
42403
42404
42405 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42406 PyObject *resultobj;
42407 wxGBSizerItem *result;
42408 char *kwnames[] = {
42409 NULL
42410 };
42411
42412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42413 {
42414 PyThreadState* __tstate = wxPyBeginAllowThreads();
42415 result = (wxGBSizerItem *)new wxGBSizerItem();
42416
42417 wxPyEndAllowThreads(__tstate);
42418 if (PyErr_Occurred()) SWIG_fail;
42419 }
42420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42421 return resultobj;
42422 fail:
42423 return NULL;
42424 }
42425
42426
42427 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42428 PyObject *resultobj;
42429 wxWindow *arg1 = (wxWindow *) 0 ;
42430 wxGBPosition *arg2 = 0 ;
42431 wxGBSpan *arg3 = 0 ;
42432 int arg4 ;
42433 int arg5 ;
42434 PyObject *arg6 = (PyObject *) NULL ;
42435 wxGBSizerItem *result;
42436 wxGBPosition temp2 ;
42437 wxGBSpan temp3 ;
42438 PyObject * obj0 = 0 ;
42439 PyObject * obj1 = 0 ;
42440 PyObject * obj2 = 0 ;
42441 PyObject * obj3 = 0 ;
42442 PyObject * obj4 = 0 ;
42443 PyObject * obj5 = 0 ;
42444 char *kwnames[] = {
42445 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42446 };
42447
42448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42450 if (SWIG_arg_fail(1)) SWIG_fail;
42451 {
42452 arg2 = &temp2;
42453 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42454 }
42455 {
42456 arg3 = &temp3;
42457 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42458 }
42459 {
42460 arg4 = (int)(SWIG_As_int(obj3));
42461 if (SWIG_arg_fail(4)) SWIG_fail;
42462 }
42463 {
42464 arg5 = (int)(SWIG_As_int(obj4));
42465 if (SWIG_arg_fail(5)) SWIG_fail;
42466 }
42467 if (obj5) {
42468 arg6 = obj5;
42469 }
42470 {
42471 PyThreadState* __tstate = wxPyBeginAllowThreads();
42472 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42473
42474 wxPyEndAllowThreads(__tstate);
42475 if (PyErr_Occurred()) SWIG_fail;
42476 }
42477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42478 return resultobj;
42479 fail:
42480 return NULL;
42481 }
42482
42483
42484 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42485 PyObject *resultobj;
42486 wxSizer *arg1 = (wxSizer *) 0 ;
42487 wxGBPosition *arg2 = 0 ;
42488 wxGBSpan *arg3 = 0 ;
42489 int arg4 ;
42490 int arg5 ;
42491 PyObject *arg6 = (PyObject *) NULL ;
42492 wxGBSizerItem *result;
42493 wxGBPosition temp2 ;
42494 wxGBSpan temp3 ;
42495 PyObject * obj0 = 0 ;
42496 PyObject * obj1 = 0 ;
42497 PyObject * obj2 = 0 ;
42498 PyObject * obj3 = 0 ;
42499 PyObject * obj4 = 0 ;
42500 PyObject * obj5 = 0 ;
42501 char *kwnames[] = {
42502 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42503 };
42504
42505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42507 if (SWIG_arg_fail(1)) SWIG_fail;
42508 {
42509 arg2 = &temp2;
42510 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42511 }
42512 {
42513 arg3 = &temp3;
42514 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42515 }
42516 {
42517 arg4 = (int)(SWIG_As_int(obj3));
42518 if (SWIG_arg_fail(4)) SWIG_fail;
42519 }
42520 {
42521 arg5 = (int)(SWIG_As_int(obj4));
42522 if (SWIG_arg_fail(5)) SWIG_fail;
42523 }
42524 if (obj5) {
42525 arg6 = obj5;
42526 }
42527 {
42528 PyThreadState* __tstate = wxPyBeginAllowThreads();
42529 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42530
42531 wxPyEndAllowThreads(__tstate);
42532 if (PyErr_Occurred()) SWIG_fail;
42533 }
42534 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42535 return resultobj;
42536 fail:
42537 return NULL;
42538 }
42539
42540
42541 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42542 PyObject *resultobj;
42543 int arg1 ;
42544 int arg2 ;
42545 wxGBPosition *arg3 = 0 ;
42546 wxGBSpan *arg4 = 0 ;
42547 int arg5 ;
42548 int arg6 ;
42549 PyObject *arg7 = (PyObject *) NULL ;
42550 wxGBSizerItem *result;
42551 wxGBPosition temp3 ;
42552 wxGBSpan temp4 ;
42553 PyObject * obj0 = 0 ;
42554 PyObject * obj1 = 0 ;
42555 PyObject * obj2 = 0 ;
42556 PyObject * obj3 = 0 ;
42557 PyObject * obj4 = 0 ;
42558 PyObject * obj5 = 0 ;
42559 PyObject * obj6 = 0 ;
42560 char *kwnames[] = {
42561 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42562 };
42563
42564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42565 {
42566 arg1 = (int)(SWIG_As_int(obj0));
42567 if (SWIG_arg_fail(1)) SWIG_fail;
42568 }
42569 {
42570 arg2 = (int)(SWIG_As_int(obj1));
42571 if (SWIG_arg_fail(2)) SWIG_fail;
42572 }
42573 {
42574 arg3 = &temp3;
42575 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42576 }
42577 {
42578 arg4 = &temp4;
42579 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42580 }
42581 {
42582 arg5 = (int)(SWIG_As_int(obj4));
42583 if (SWIG_arg_fail(5)) SWIG_fail;
42584 }
42585 {
42586 arg6 = (int)(SWIG_As_int(obj5));
42587 if (SWIG_arg_fail(6)) SWIG_fail;
42588 }
42589 if (obj6) {
42590 arg7 = obj6;
42591 }
42592 {
42593 PyThreadState* __tstate = wxPyBeginAllowThreads();
42594 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42595
42596 wxPyEndAllowThreads(__tstate);
42597 if (PyErr_Occurred()) SWIG_fail;
42598 }
42599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42600 return resultobj;
42601 fail:
42602 return NULL;
42603 }
42604
42605
42606 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42607 PyObject *resultobj;
42608 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42609 wxGBPosition result;
42610 PyObject * obj0 = 0 ;
42611 char *kwnames[] = {
42612 (char *) "self", NULL
42613 };
42614
42615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42617 if (SWIG_arg_fail(1)) SWIG_fail;
42618 {
42619 PyThreadState* __tstate = wxPyBeginAllowThreads();
42620 result = ((wxGBSizerItem const *)arg1)->GetPos();
42621
42622 wxPyEndAllowThreads(__tstate);
42623 if (PyErr_Occurred()) SWIG_fail;
42624 }
42625 {
42626 wxGBPosition * resultptr;
42627 resultptr = new wxGBPosition((wxGBPosition &)(result));
42628 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42629 }
42630 return resultobj;
42631 fail:
42632 return NULL;
42633 }
42634
42635
42636 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42637 PyObject *resultobj;
42638 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42639 wxGBSpan result;
42640 PyObject * obj0 = 0 ;
42641 char *kwnames[] = {
42642 (char *) "self", NULL
42643 };
42644
42645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42647 if (SWIG_arg_fail(1)) SWIG_fail;
42648 {
42649 PyThreadState* __tstate = wxPyBeginAllowThreads();
42650 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42651
42652 wxPyEndAllowThreads(__tstate);
42653 if (PyErr_Occurred()) SWIG_fail;
42654 }
42655 {
42656 wxGBSpan * resultptr;
42657 resultptr = new wxGBSpan((wxGBSpan &)(result));
42658 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42659 }
42660 return resultobj;
42661 fail:
42662 return NULL;
42663 }
42664
42665
42666 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42667 PyObject *resultobj;
42668 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42669 wxGBPosition *arg2 = 0 ;
42670 bool result;
42671 wxGBPosition temp2 ;
42672 PyObject * obj0 = 0 ;
42673 PyObject * obj1 = 0 ;
42674 char *kwnames[] = {
42675 (char *) "self",(char *) "pos", NULL
42676 };
42677
42678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42680 if (SWIG_arg_fail(1)) SWIG_fail;
42681 {
42682 arg2 = &temp2;
42683 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42684 }
42685 {
42686 PyThreadState* __tstate = wxPyBeginAllowThreads();
42687 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42688
42689 wxPyEndAllowThreads(__tstate);
42690 if (PyErr_Occurred()) SWIG_fail;
42691 }
42692 {
42693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42694 }
42695 return resultobj;
42696 fail:
42697 return NULL;
42698 }
42699
42700
42701 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42702 PyObject *resultobj;
42703 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42704 wxGBSpan *arg2 = 0 ;
42705 bool result;
42706 wxGBSpan temp2 ;
42707 PyObject * obj0 = 0 ;
42708 PyObject * obj1 = 0 ;
42709 char *kwnames[] = {
42710 (char *) "self",(char *) "span", NULL
42711 };
42712
42713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42715 if (SWIG_arg_fail(1)) SWIG_fail;
42716 {
42717 arg2 = &temp2;
42718 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42719 }
42720 {
42721 PyThreadState* __tstate = wxPyBeginAllowThreads();
42722 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42723
42724 wxPyEndAllowThreads(__tstate);
42725 if (PyErr_Occurred()) SWIG_fail;
42726 }
42727 {
42728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42729 }
42730 return resultobj;
42731 fail:
42732 return NULL;
42733 }
42734
42735
42736 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42737 PyObject *resultobj;
42738 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42739 wxGBSizerItem *arg2 = 0 ;
42740 bool result;
42741 PyObject * obj0 = 0 ;
42742 PyObject * obj1 = 0 ;
42743 char *kwnames[] = {
42744 (char *) "self",(char *) "other", NULL
42745 };
42746
42747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42749 if (SWIG_arg_fail(1)) SWIG_fail;
42750 {
42751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42752 if (SWIG_arg_fail(2)) SWIG_fail;
42753 if (arg2 == NULL) {
42754 SWIG_null_ref("wxGBSizerItem");
42755 }
42756 if (SWIG_arg_fail(2)) SWIG_fail;
42757 }
42758 {
42759 PyThreadState* __tstate = wxPyBeginAllowThreads();
42760 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42761
42762 wxPyEndAllowThreads(__tstate);
42763 if (PyErr_Occurred()) SWIG_fail;
42764 }
42765 {
42766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42767 }
42768 return resultobj;
42769 fail:
42770 return NULL;
42771 }
42772
42773
42774 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42775 PyObject *resultobj;
42776 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42777 wxGBPosition *arg2 = 0 ;
42778 wxGBSpan *arg3 = 0 ;
42779 bool result;
42780 wxGBPosition temp2 ;
42781 wxGBSpan temp3 ;
42782 PyObject * obj0 = 0 ;
42783 PyObject * obj1 = 0 ;
42784 PyObject * obj2 = 0 ;
42785 char *kwnames[] = {
42786 (char *) "self",(char *) "pos",(char *) "span", NULL
42787 };
42788
42789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42791 if (SWIG_arg_fail(1)) SWIG_fail;
42792 {
42793 arg2 = &temp2;
42794 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42795 }
42796 {
42797 arg3 = &temp3;
42798 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42799 }
42800 {
42801 PyThreadState* __tstate = wxPyBeginAllowThreads();
42802 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42803
42804 wxPyEndAllowThreads(__tstate);
42805 if (PyErr_Occurred()) SWIG_fail;
42806 }
42807 {
42808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42809 }
42810 return resultobj;
42811 fail:
42812 return NULL;
42813 }
42814
42815
42816 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42817 PyObject *resultobj;
42818 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42819 wxGBPosition result;
42820 PyObject * obj0 = 0 ;
42821 char *kwnames[] = {
42822 (char *) "self", NULL
42823 };
42824
42825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42827 if (SWIG_arg_fail(1)) SWIG_fail;
42828 {
42829 PyThreadState* __tstate = wxPyBeginAllowThreads();
42830 result = wxGBSizerItem_GetEndPos(arg1);
42831
42832 wxPyEndAllowThreads(__tstate);
42833 if (PyErr_Occurred()) SWIG_fail;
42834 }
42835 {
42836 wxGBPosition * resultptr;
42837 resultptr = new wxGBPosition((wxGBPosition &)(result));
42838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42839 }
42840 return resultobj;
42841 fail:
42842 return NULL;
42843 }
42844
42845
42846 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42847 PyObject *resultobj;
42848 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42849 wxGridBagSizer *result;
42850 PyObject * obj0 = 0 ;
42851 char *kwnames[] = {
42852 (char *) "self", NULL
42853 };
42854
42855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42857 if (SWIG_arg_fail(1)) SWIG_fail;
42858 {
42859 PyThreadState* __tstate = wxPyBeginAllowThreads();
42860 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42861
42862 wxPyEndAllowThreads(__tstate);
42863 if (PyErr_Occurred()) SWIG_fail;
42864 }
42865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42866 return resultobj;
42867 fail:
42868 return NULL;
42869 }
42870
42871
42872 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42873 PyObject *resultobj;
42874 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42875 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42876 PyObject * obj0 = 0 ;
42877 PyObject * obj1 = 0 ;
42878 char *kwnames[] = {
42879 (char *) "self",(char *) "sizer", NULL
42880 };
42881
42882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42884 if (SWIG_arg_fail(1)) SWIG_fail;
42885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42886 if (SWIG_arg_fail(2)) SWIG_fail;
42887 {
42888 PyThreadState* __tstate = wxPyBeginAllowThreads();
42889 (arg1)->SetGBSizer(arg2);
42890
42891 wxPyEndAllowThreads(__tstate);
42892 if (PyErr_Occurred()) SWIG_fail;
42893 }
42894 Py_INCREF(Py_None); resultobj = Py_None;
42895 return resultobj;
42896 fail:
42897 return NULL;
42898 }
42899
42900
42901 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42902 PyObject *obj;
42903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42904 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42905 Py_INCREF(obj);
42906 return Py_BuildValue((char *)"");
42907 }
42908 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42909 PyObject *resultobj;
42910 int arg1 = (int) 0 ;
42911 int arg2 = (int) 0 ;
42912 wxGridBagSizer *result;
42913 PyObject * obj0 = 0 ;
42914 PyObject * obj1 = 0 ;
42915 char *kwnames[] = {
42916 (char *) "vgap",(char *) "hgap", NULL
42917 };
42918
42919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42920 if (obj0) {
42921 {
42922 arg1 = (int)(SWIG_As_int(obj0));
42923 if (SWIG_arg_fail(1)) SWIG_fail;
42924 }
42925 }
42926 if (obj1) {
42927 {
42928 arg2 = (int)(SWIG_As_int(obj1));
42929 if (SWIG_arg_fail(2)) SWIG_fail;
42930 }
42931 }
42932 {
42933 PyThreadState* __tstate = wxPyBeginAllowThreads();
42934 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42935
42936 wxPyEndAllowThreads(__tstate);
42937 if (PyErr_Occurred()) SWIG_fail;
42938 }
42939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42940 return resultobj;
42941 fail:
42942 return NULL;
42943 }
42944
42945
42946 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42947 PyObject *resultobj;
42948 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42949 PyObject *arg2 = (PyObject *) 0 ;
42950 wxGBPosition *arg3 = 0 ;
42951 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42952 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42953 int arg5 = (int) 0 ;
42954 int arg6 = (int) 0 ;
42955 PyObject *arg7 = (PyObject *) NULL ;
42956 wxGBSizerItem *result;
42957 wxGBPosition temp3 ;
42958 wxGBSpan temp4 ;
42959 PyObject * obj0 = 0 ;
42960 PyObject * obj1 = 0 ;
42961 PyObject * obj2 = 0 ;
42962 PyObject * obj3 = 0 ;
42963 PyObject * obj4 = 0 ;
42964 PyObject * obj5 = 0 ;
42965 PyObject * obj6 = 0 ;
42966 char *kwnames[] = {
42967 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42968 };
42969
42970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42972 if (SWIG_arg_fail(1)) SWIG_fail;
42973 arg2 = obj1;
42974 {
42975 arg3 = &temp3;
42976 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42977 }
42978 if (obj3) {
42979 {
42980 arg4 = &temp4;
42981 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42982 }
42983 }
42984 if (obj4) {
42985 {
42986 arg5 = (int)(SWIG_As_int(obj4));
42987 if (SWIG_arg_fail(5)) SWIG_fail;
42988 }
42989 }
42990 if (obj5) {
42991 {
42992 arg6 = (int)(SWIG_As_int(obj5));
42993 if (SWIG_arg_fail(6)) SWIG_fail;
42994 }
42995 }
42996 if (obj6) {
42997 arg7 = obj6;
42998 }
42999 {
43000 PyThreadState* __tstate = wxPyBeginAllowThreads();
43001 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43002
43003 wxPyEndAllowThreads(__tstate);
43004 if (PyErr_Occurred()) SWIG_fail;
43005 }
43006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43007 return resultobj;
43008 fail:
43009 return NULL;
43010 }
43011
43012
43013 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43014 PyObject *resultobj;
43015 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43016 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43017 wxGBSizerItem *result;
43018 PyObject * obj0 = 0 ;
43019 PyObject * obj1 = 0 ;
43020 char *kwnames[] = {
43021 (char *) "self",(char *) "item", NULL
43022 };
43023
43024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43026 if (SWIG_arg_fail(1)) SWIG_fail;
43027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43028 if (SWIG_arg_fail(2)) SWIG_fail;
43029 {
43030 PyThreadState* __tstate = wxPyBeginAllowThreads();
43031 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43032
43033 wxPyEndAllowThreads(__tstate);
43034 if (PyErr_Occurred()) SWIG_fail;
43035 }
43036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43037 return resultobj;
43038 fail:
43039 return NULL;
43040 }
43041
43042
43043 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43044 PyObject *resultobj;
43045 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43046 int arg2 ;
43047 int arg3 ;
43048 wxSize result;
43049 PyObject * obj0 = 0 ;
43050 PyObject * obj1 = 0 ;
43051 PyObject * obj2 = 0 ;
43052 char *kwnames[] = {
43053 (char *) "self",(char *) "row",(char *) "col", NULL
43054 };
43055
43056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43058 if (SWIG_arg_fail(1)) SWIG_fail;
43059 {
43060 arg2 = (int)(SWIG_As_int(obj1));
43061 if (SWIG_arg_fail(2)) SWIG_fail;
43062 }
43063 {
43064 arg3 = (int)(SWIG_As_int(obj2));
43065 if (SWIG_arg_fail(3)) SWIG_fail;
43066 }
43067 {
43068 PyThreadState* __tstate = wxPyBeginAllowThreads();
43069 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43070
43071 wxPyEndAllowThreads(__tstate);
43072 if (PyErr_Occurred()) SWIG_fail;
43073 }
43074 {
43075 wxSize * resultptr;
43076 resultptr = new wxSize((wxSize &)(result));
43077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43078 }
43079 return resultobj;
43080 fail:
43081 return NULL;
43082 }
43083
43084
43085 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43086 PyObject *resultobj;
43087 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43088 wxSize result;
43089 PyObject * obj0 = 0 ;
43090 char *kwnames[] = {
43091 (char *) "self", NULL
43092 };
43093
43094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43096 if (SWIG_arg_fail(1)) SWIG_fail;
43097 {
43098 PyThreadState* __tstate = wxPyBeginAllowThreads();
43099 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43100
43101 wxPyEndAllowThreads(__tstate);
43102 if (PyErr_Occurred()) SWIG_fail;
43103 }
43104 {
43105 wxSize * resultptr;
43106 resultptr = new wxSize((wxSize &)(result));
43107 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43108 }
43109 return resultobj;
43110 fail:
43111 return NULL;
43112 }
43113
43114
43115 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43116 PyObject *resultobj;
43117 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43118 wxSize *arg2 = 0 ;
43119 wxSize temp2 ;
43120 PyObject * obj0 = 0 ;
43121 PyObject * obj1 = 0 ;
43122 char *kwnames[] = {
43123 (char *) "self",(char *) "sz", NULL
43124 };
43125
43126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43128 if (SWIG_arg_fail(1)) SWIG_fail;
43129 {
43130 arg2 = &temp2;
43131 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43132 }
43133 {
43134 PyThreadState* __tstate = wxPyBeginAllowThreads();
43135 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43136
43137 wxPyEndAllowThreads(__tstate);
43138 if (PyErr_Occurred()) SWIG_fail;
43139 }
43140 Py_INCREF(Py_None); resultobj = Py_None;
43141 return resultobj;
43142 fail:
43143 return NULL;
43144 }
43145
43146
43147 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43148 PyObject *resultobj;
43149 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43150 wxWindow *arg2 = (wxWindow *) 0 ;
43151 wxGBPosition result;
43152 PyObject * obj0 = 0 ;
43153 PyObject * obj1 = 0 ;
43154
43155 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43157 if (SWIG_arg_fail(1)) SWIG_fail;
43158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43159 if (SWIG_arg_fail(2)) SWIG_fail;
43160 {
43161 PyThreadState* __tstate = wxPyBeginAllowThreads();
43162 result = (arg1)->GetItemPosition(arg2);
43163
43164 wxPyEndAllowThreads(__tstate);
43165 if (PyErr_Occurred()) SWIG_fail;
43166 }
43167 {
43168 wxGBPosition * resultptr;
43169 resultptr = new wxGBPosition((wxGBPosition &)(result));
43170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43171 }
43172 return resultobj;
43173 fail:
43174 return NULL;
43175 }
43176
43177
43178 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43179 PyObject *resultobj;
43180 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43181 wxSizer *arg2 = (wxSizer *) 0 ;
43182 wxGBPosition result;
43183 PyObject * obj0 = 0 ;
43184 PyObject * obj1 = 0 ;
43185
43186 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43188 if (SWIG_arg_fail(1)) SWIG_fail;
43189 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43190 if (SWIG_arg_fail(2)) SWIG_fail;
43191 {
43192 PyThreadState* __tstate = wxPyBeginAllowThreads();
43193 result = (arg1)->GetItemPosition(arg2);
43194
43195 wxPyEndAllowThreads(__tstate);
43196 if (PyErr_Occurred()) SWIG_fail;
43197 }
43198 {
43199 wxGBPosition * resultptr;
43200 resultptr = new wxGBPosition((wxGBPosition &)(result));
43201 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43202 }
43203 return resultobj;
43204 fail:
43205 return NULL;
43206 }
43207
43208
43209 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43210 PyObject *resultobj;
43211 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43212 size_t arg2 ;
43213 wxGBPosition result;
43214 PyObject * obj0 = 0 ;
43215 PyObject * obj1 = 0 ;
43216
43217 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43219 if (SWIG_arg_fail(1)) SWIG_fail;
43220 {
43221 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43222 if (SWIG_arg_fail(2)) SWIG_fail;
43223 }
43224 {
43225 PyThreadState* __tstate = wxPyBeginAllowThreads();
43226 result = (arg1)->GetItemPosition(arg2);
43227
43228 wxPyEndAllowThreads(__tstate);
43229 if (PyErr_Occurred()) SWIG_fail;
43230 }
43231 {
43232 wxGBPosition * resultptr;
43233 resultptr = new wxGBPosition((wxGBPosition &)(result));
43234 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43235 }
43236 return resultobj;
43237 fail:
43238 return NULL;
43239 }
43240
43241
43242 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43243 int argc;
43244 PyObject *argv[3];
43245 int ii;
43246
43247 argc = PyObject_Length(args);
43248 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43249 argv[ii] = PyTuple_GetItem(args,ii);
43250 }
43251 if (argc == 2) {
43252 int _v;
43253 {
43254 void *ptr;
43255 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43256 _v = 0;
43257 PyErr_Clear();
43258 } else {
43259 _v = 1;
43260 }
43261 }
43262 if (_v) {
43263 {
43264 void *ptr;
43265 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43266 _v = 0;
43267 PyErr_Clear();
43268 } else {
43269 _v = 1;
43270 }
43271 }
43272 if (_v) {
43273 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43274 }
43275 }
43276 }
43277 if (argc == 2) {
43278 int _v;
43279 {
43280 void *ptr;
43281 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43282 _v = 0;
43283 PyErr_Clear();
43284 } else {
43285 _v = 1;
43286 }
43287 }
43288 if (_v) {
43289 {
43290 void *ptr;
43291 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43292 _v = 0;
43293 PyErr_Clear();
43294 } else {
43295 _v = 1;
43296 }
43297 }
43298 if (_v) {
43299 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43300 }
43301 }
43302 }
43303 if (argc == 2) {
43304 int _v;
43305 {
43306 void *ptr;
43307 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43308 _v = 0;
43309 PyErr_Clear();
43310 } else {
43311 _v = 1;
43312 }
43313 }
43314 if (_v) {
43315 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43316 if (_v) {
43317 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43318 }
43319 }
43320 }
43321
43322 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43323 return NULL;
43324 }
43325
43326
43327 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43328 PyObject *resultobj;
43329 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43330 wxWindow *arg2 = (wxWindow *) 0 ;
43331 wxGBPosition *arg3 = 0 ;
43332 bool result;
43333 wxGBPosition temp3 ;
43334 PyObject * obj0 = 0 ;
43335 PyObject * obj1 = 0 ;
43336 PyObject * obj2 = 0 ;
43337
43338 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43340 if (SWIG_arg_fail(1)) SWIG_fail;
43341 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43342 if (SWIG_arg_fail(2)) SWIG_fail;
43343 {
43344 arg3 = &temp3;
43345 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43346 }
43347 {
43348 PyThreadState* __tstate = wxPyBeginAllowThreads();
43349 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43350
43351 wxPyEndAllowThreads(__tstate);
43352 if (PyErr_Occurred()) SWIG_fail;
43353 }
43354 {
43355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43356 }
43357 return resultobj;
43358 fail:
43359 return NULL;
43360 }
43361
43362
43363 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43364 PyObject *resultobj;
43365 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43366 wxSizer *arg2 = (wxSizer *) 0 ;
43367 wxGBPosition *arg3 = 0 ;
43368 bool result;
43369 wxGBPosition temp3 ;
43370 PyObject * obj0 = 0 ;
43371 PyObject * obj1 = 0 ;
43372 PyObject * obj2 = 0 ;
43373
43374 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) 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_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43378 if (SWIG_arg_fail(2)) SWIG_fail;
43379 {
43380 arg3 = &temp3;
43381 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43382 }
43383 {
43384 PyThreadState* __tstate = wxPyBeginAllowThreads();
43385 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43386
43387 wxPyEndAllowThreads(__tstate);
43388 if (PyErr_Occurred()) SWIG_fail;
43389 }
43390 {
43391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43392 }
43393 return resultobj;
43394 fail:
43395 return NULL;
43396 }
43397
43398
43399 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43400 PyObject *resultobj;
43401 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43402 size_t arg2 ;
43403 wxGBPosition *arg3 = 0 ;
43404 bool result;
43405 wxGBPosition temp3 ;
43406 PyObject * obj0 = 0 ;
43407 PyObject * obj1 = 0 ;
43408 PyObject * obj2 = 0 ;
43409
43410 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43412 if (SWIG_arg_fail(1)) SWIG_fail;
43413 {
43414 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43415 if (SWIG_arg_fail(2)) SWIG_fail;
43416 }
43417 {
43418 arg3 = &temp3;
43419 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43420 }
43421 {
43422 PyThreadState* __tstate = wxPyBeginAllowThreads();
43423 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43424
43425 wxPyEndAllowThreads(__tstate);
43426 if (PyErr_Occurred()) SWIG_fail;
43427 }
43428 {
43429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43430 }
43431 return resultobj;
43432 fail:
43433 return NULL;
43434 }
43435
43436
43437 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43438 int argc;
43439 PyObject *argv[4];
43440 int ii;
43441
43442 argc = PyObject_Length(args);
43443 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43444 argv[ii] = PyTuple_GetItem(args,ii);
43445 }
43446 if (argc == 3) {
43447 int _v;
43448 {
43449 void *ptr;
43450 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43451 _v = 0;
43452 PyErr_Clear();
43453 } else {
43454 _v = 1;
43455 }
43456 }
43457 if (_v) {
43458 {
43459 void *ptr;
43460 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43461 _v = 0;
43462 PyErr_Clear();
43463 } else {
43464 _v = 1;
43465 }
43466 }
43467 if (_v) {
43468 {
43469 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43470 }
43471 if (_v) {
43472 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43473 }
43474 }
43475 }
43476 }
43477 if (argc == 3) {
43478 int _v;
43479 {
43480 void *ptr;
43481 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43482 _v = 0;
43483 PyErr_Clear();
43484 } else {
43485 _v = 1;
43486 }
43487 }
43488 if (_v) {
43489 {
43490 void *ptr;
43491 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43492 _v = 0;
43493 PyErr_Clear();
43494 } else {
43495 _v = 1;
43496 }
43497 }
43498 if (_v) {
43499 {
43500 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43501 }
43502 if (_v) {
43503 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43504 }
43505 }
43506 }
43507 }
43508 if (argc == 3) {
43509 int _v;
43510 {
43511 void *ptr;
43512 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43513 _v = 0;
43514 PyErr_Clear();
43515 } else {
43516 _v = 1;
43517 }
43518 }
43519 if (_v) {
43520 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43521 if (_v) {
43522 {
43523 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43524 }
43525 if (_v) {
43526 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43527 }
43528 }
43529 }
43530 }
43531
43532 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43533 return NULL;
43534 }
43535
43536
43537 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43538 PyObject *resultobj;
43539 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43540 wxWindow *arg2 = (wxWindow *) 0 ;
43541 wxGBSpan result;
43542 PyObject * obj0 = 0 ;
43543 PyObject * obj1 = 0 ;
43544
43545 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43547 if (SWIG_arg_fail(1)) SWIG_fail;
43548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43549 if (SWIG_arg_fail(2)) SWIG_fail;
43550 {
43551 PyThreadState* __tstate = wxPyBeginAllowThreads();
43552 result = (arg1)->GetItemSpan(arg2);
43553
43554 wxPyEndAllowThreads(__tstate);
43555 if (PyErr_Occurred()) SWIG_fail;
43556 }
43557 {
43558 wxGBSpan * resultptr;
43559 resultptr = new wxGBSpan((wxGBSpan &)(result));
43560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43561 }
43562 return resultobj;
43563 fail:
43564 return NULL;
43565 }
43566
43567
43568 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43569 PyObject *resultobj;
43570 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43571 wxSizer *arg2 = (wxSizer *) 0 ;
43572 wxGBSpan result;
43573 PyObject * obj0 = 0 ;
43574 PyObject * obj1 = 0 ;
43575
43576 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43578 if (SWIG_arg_fail(1)) SWIG_fail;
43579 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43580 if (SWIG_arg_fail(2)) SWIG_fail;
43581 {
43582 PyThreadState* __tstate = wxPyBeginAllowThreads();
43583 result = (arg1)->GetItemSpan(arg2);
43584
43585 wxPyEndAllowThreads(__tstate);
43586 if (PyErr_Occurred()) SWIG_fail;
43587 }
43588 {
43589 wxGBSpan * resultptr;
43590 resultptr = new wxGBSpan((wxGBSpan &)(result));
43591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43592 }
43593 return resultobj;
43594 fail:
43595 return NULL;
43596 }
43597
43598
43599 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43600 PyObject *resultobj;
43601 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43602 size_t arg2 ;
43603 wxGBSpan result;
43604 PyObject * obj0 = 0 ;
43605 PyObject * obj1 = 0 ;
43606
43607 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43609 if (SWIG_arg_fail(1)) SWIG_fail;
43610 {
43611 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43612 if (SWIG_arg_fail(2)) SWIG_fail;
43613 }
43614 {
43615 PyThreadState* __tstate = wxPyBeginAllowThreads();
43616 result = (arg1)->GetItemSpan(arg2);
43617
43618 wxPyEndAllowThreads(__tstate);
43619 if (PyErr_Occurred()) SWIG_fail;
43620 }
43621 {
43622 wxGBSpan * resultptr;
43623 resultptr = new wxGBSpan((wxGBSpan &)(result));
43624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43625 }
43626 return resultobj;
43627 fail:
43628 return NULL;
43629 }
43630
43631
43632 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43633 int argc;
43634 PyObject *argv[3];
43635 int ii;
43636
43637 argc = PyObject_Length(args);
43638 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43639 argv[ii] = PyTuple_GetItem(args,ii);
43640 }
43641 if (argc == 2) {
43642 int _v;
43643 {
43644 void *ptr;
43645 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43646 _v = 0;
43647 PyErr_Clear();
43648 } else {
43649 _v = 1;
43650 }
43651 }
43652 if (_v) {
43653 {
43654 void *ptr;
43655 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43656 _v = 0;
43657 PyErr_Clear();
43658 } else {
43659 _v = 1;
43660 }
43661 }
43662 if (_v) {
43663 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43664 }
43665 }
43666 }
43667 if (argc == 2) {
43668 int _v;
43669 {
43670 void *ptr;
43671 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43672 _v = 0;
43673 PyErr_Clear();
43674 } else {
43675 _v = 1;
43676 }
43677 }
43678 if (_v) {
43679 {
43680 void *ptr;
43681 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43682 _v = 0;
43683 PyErr_Clear();
43684 } else {
43685 _v = 1;
43686 }
43687 }
43688 if (_v) {
43689 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43690 }
43691 }
43692 }
43693 if (argc == 2) {
43694 int _v;
43695 {
43696 void *ptr;
43697 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43698 _v = 0;
43699 PyErr_Clear();
43700 } else {
43701 _v = 1;
43702 }
43703 }
43704 if (_v) {
43705 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43706 if (_v) {
43707 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43708 }
43709 }
43710 }
43711
43712 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43713 return NULL;
43714 }
43715
43716
43717 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43718 PyObject *resultobj;
43719 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43720 wxWindow *arg2 = (wxWindow *) 0 ;
43721 wxGBSpan *arg3 = 0 ;
43722 bool result;
43723 wxGBSpan temp3 ;
43724 PyObject * obj0 = 0 ;
43725 PyObject * obj1 = 0 ;
43726 PyObject * obj2 = 0 ;
43727
43728 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43730 if (SWIG_arg_fail(1)) SWIG_fail;
43731 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43732 if (SWIG_arg_fail(2)) SWIG_fail;
43733 {
43734 arg3 = &temp3;
43735 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43736 }
43737 {
43738 PyThreadState* __tstate = wxPyBeginAllowThreads();
43739 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43740
43741 wxPyEndAllowThreads(__tstate);
43742 if (PyErr_Occurred()) SWIG_fail;
43743 }
43744 {
43745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43746 }
43747 return resultobj;
43748 fail:
43749 return NULL;
43750 }
43751
43752
43753 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43754 PyObject *resultobj;
43755 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43756 wxSizer *arg2 = (wxSizer *) 0 ;
43757 wxGBSpan *arg3 = 0 ;
43758 bool result;
43759 wxGBSpan temp3 ;
43760 PyObject * obj0 = 0 ;
43761 PyObject * obj1 = 0 ;
43762 PyObject * obj2 = 0 ;
43763
43764 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43766 if (SWIG_arg_fail(1)) SWIG_fail;
43767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43768 if (SWIG_arg_fail(2)) SWIG_fail;
43769 {
43770 arg3 = &temp3;
43771 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43772 }
43773 {
43774 PyThreadState* __tstate = wxPyBeginAllowThreads();
43775 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43776
43777 wxPyEndAllowThreads(__tstate);
43778 if (PyErr_Occurred()) SWIG_fail;
43779 }
43780 {
43781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43782 }
43783 return resultobj;
43784 fail:
43785 return NULL;
43786 }
43787
43788
43789 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43790 PyObject *resultobj;
43791 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43792 size_t arg2 ;
43793 wxGBSpan *arg3 = 0 ;
43794 bool result;
43795 wxGBSpan temp3 ;
43796 PyObject * obj0 = 0 ;
43797 PyObject * obj1 = 0 ;
43798 PyObject * obj2 = 0 ;
43799
43800 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43802 if (SWIG_arg_fail(1)) SWIG_fail;
43803 {
43804 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43805 if (SWIG_arg_fail(2)) SWIG_fail;
43806 }
43807 {
43808 arg3 = &temp3;
43809 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43810 }
43811 {
43812 PyThreadState* __tstate = wxPyBeginAllowThreads();
43813 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43814
43815 wxPyEndAllowThreads(__tstate);
43816 if (PyErr_Occurred()) SWIG_fail;
43817 }
43818 {
43819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43820 }
43821 return resultobj;
43822 fail:
43823 return NULL;
43824 }
43825
43826
43827 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43828 int argc;
43829 PyObject *argv[4];
43830 int ii;
43831
43832 argc = PyObject_Length(args);
43833 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43834 argv[ii] = PyTuple_GetItem(args,ii);
43835 }
43836 if (argc == 3) {
43837 int _v;
43838 {
43839 void *ptr;
43840 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43841 _v = 0;
43842 PyErr_Clear();
43843 } else {
43844 _v = 1;
43845 }
43846 }
43847 if (_v) {
43848 {
43849 void *ptr;
43850 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43851 _v = 0;
43852 PyErr_Clear();
43853 } else {
43854 _v = 1;
43855 }
43856 }
43857 if (_v) {
43858 {
43859 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43860 }
43861 if (_v) {
43862 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43863 }
43864 }
43865 }
43866 }
43867 if (argc == 3) {
43868 int _v;
43869 {
43870 void *ptr;
43871 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43872 _v = 0;
43873 PyErr_Clear();
43874 } else {
43875 _v = 1;
43876 }
43877 }
43878 if (_v) {
43879 {
43880 void *ptr;
43881 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43882 _v = 0;
43883 PyErr_Clear();
43884 } else {
43885 _v = 1;
43886 }
43887 }
43888 if (_v) {
43889 {
43890 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43891 }
43892 if (_v) {
43893 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43894 }
43895 }
43896 }
43897 }
43898 if (argc == 3) {
43899 int _v;
43900 {
43901 void *ptr;
43902 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43903 _v = 0;
43904 PyErr_Clear();
43905 } else {
43906 _v = 1;
43907 }
43908 }
43909 if (_v) {
43910 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43911 if (_v) {
43912 {
43913 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43914 }
43915 if (_v) {
43916 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43917 }
43918 }
43919 }
43920 }
43921
43922 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43923 return NULL;
43924 }
43925
43926
43927 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43928 PyObject *resultobj;
43929 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43930 wxWindow *arg2 = (wxWindow *) 0 ;
43931 wxGBSizerItem *result;
43932 PyObject * obj0 = 0 ;
43933 PyObject * obj1 = 0 ;
43934
43935 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43937 if (SWIG_arg_fail(1)) SWIG_fail;
43938 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43939 if (SWIG_arg_fail(2)) SWIG_fail;
43940 {
43941 PyThreadState* __tstate = wxPyBeginAllowThreads();
43942 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43943
43944 wxPyEndAllowThreads(__tstate);
43945 if (PyErr_Occurred()) SWIG_fail;
43946 }
43947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43948 return resultobj;
43949 fail:
43950 return NULL;
43951 }
43952
43953
43954 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43955 PyObject *resultobj;
43956 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43957 wxSizer *arg2 = (wxSizer *) 0 ;
43958 wxGBSizerItem *result;
43959 PyObject * obj0 = 0 ;
43960 PyObject * obj1 = 0 ;
43961
43962 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43964 if (SWIG_arg_fail(1)) SWIG_fail;
43965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43966 if (SWIG_arg_fail(2)) SWIG_fail;
43967 {
43968 PyThreadState* __tstate = wxPyBeginAllowThreads();
43969 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43970
43971 wxPyEndAllowThreads(__tstate);
43972 if (PyErr_Occurred()) SWIG_fail;
43973 }
43974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43975 return resultobj;
43976 fail:
43977 return NULL;
43978 }
43979
43980
43981 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43982 int argc;
43983 PyObject *argv[3];
43984 int ii;
43985
43986 argc = PyObject_Length(args);
43987 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43988 argv[ii] = PyTuple_GetItem(args,ii);
43989 }
43990 if (argc == 2) {
43991 int _v;
43992 {
43993 void *ptr;
43994 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43995 _v = 0;
43996 PyErr_Clear();
43997 } else {
43998 _v = 1;
43999 }
44000 }
44001 if (_v) {
44002 {
44003 void *ptr;
44004 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44005 _v = 0;
44006 PyErr_Clear();
44007 } else {
44008 _v = 1;
44009 }
44010 }
44011 if (_v) {
44012 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44013 }
44014 }
44015 }
44016 if (argc == 2) {
44017 int _v;
44018 {
44019 void *ptr;
44020 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44021 _v = 0;
44022 PyErr_Clear();
44023 } else {
44024 _v = 1;
44025 }
44026 }
44027 if (_v) {
44028 {
44029 void *ptr;
44030 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44031 _v = 0;
44032 PyErr_Clear();
44033 } else {
44034 _v = 1;
44035 }
44036 }
44037 if (_v) {
44038 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44039 }
44040 }
44041 }
44042
44043 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44044 return NULL;
44045 }
44046
44047
44048 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44049 PyObject *resultobj;
44050 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44051 wxGBPosition *arg2 = 0 ;
44052 wxGBSizerItem *result;
44053 wxGBPosition temp2 ;
44054 PyObject * obj0 = 0 ;
44055 PyObject * obj1 = 0 ;
44056 char *kwnames[] = {
44057 (char *) "self",(char *) "pos", NULL
44058 };
44059
44060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44062 if (SWIG_arg_fail(1)) SWIG_fail;
44063 {
44064 arg2 = &temp2;
44065 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44066 }
44067 {
44068 PyThreadState* __tstate = wxPyBeginAllowThreads();
44069 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44070
44071 wxPyEndAllowThreads(__tstate);
44072 if (PyErr_Occurred()) SWIG_fail;
44073 }
44074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44075 return resultobj;
44076 fail:
44077 return NULL;
44078 }
44079
44080
44081 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44082 PyObject *resultobj;
44083 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44084 wxPoint *arg2 = 0 ;
44085 wxGBSizerItem *result;
44086 wxPoint temp2 ;
44087 PyObject * obj0 = 0 ;
44088 PyObject * obj1 = 0 ;
44089 char *kwnames[] = {
44090 (char *) "self",(char *) "pt", NULL
44091 };
44092
44093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44095 if (SWIG_arg_fail(1)) SWIG_fail;
44096 {
44097 arg2 = &temp2;
44098 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44099 }
44100 {
44101 PyThreadState* __tstate = wxPyBeginAllowThreads();
44102 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44103
44104 wxPyEndAllowThreads(__tstate);
44105 if (PyErr_Occurred()) SWIG_fail;
44106 }
44107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44108 return resultobj;
44109 fail:
44110 return NULL;
44111 }
44112
44113
44114 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44115 PyObject *resultobj;
44116 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44117 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44118 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44119 bool result;
44120 PyObject * obj0 = 0 ;
44121 PyObject * obj1 = 0 ;
44122 PyObject * obj2 = 0 ;
44123 char *kwnames[] = {
44124 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44125 };
44126
44127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44129 if (SWIG_arg_fail(1)) SWIG_fail;
44130 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44131 if (SWIG_arg_fail(2)) SWIG_fail;
44132 if (obj2) {
44133 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44134 if (SWIG_arg_fail(3)) SWIG_fail;
44135 }
44136 {
44137 PyThreadState* __tstate = wxPyBeginAllowThreads();
44138 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44139
44140 wxPyEndAllowThreads(__tstate);
44141 if (PyErr_Occurred()) SWIG_fail;
44142 }
44143 {
44144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44145 }
44146 return resultobj;
44147 fail:
44148 return NULL;
44149 }
44150
44151
44152 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44153 PyObject *resultobj;
44154 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44155 wxGBPosition *arg2 = 0 ;
44156 wxGBSpan *arg3 = 0 ;
44157 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44158 bool result;
44159 wxGBPosition temp2 ;
44160 wxGBSpan temp3 ;
44161 PyObject * obj0 = 0 ;
44162 PyObject * obj1 = 0 ;
44163 PyObject * obj2 = 0 ;
44164 PyObject * obj3 = 0 ;
44165 char *kwnames[] = {
44166 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44167 };
44168
44169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44171 if (SWIG_arg_fail(1)) SWIG_fail;
44172 {
44173 arg2 = &temp2;
44174 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44175 }
44176 {
44177 arg3 = &temp3;
44178 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44179 }
44180 if (obj3) {
44181 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44182 if (SWIG_arg_fail(4)) SWIG_fail;
44183 }
44184 {
44185 PyThreadState* __tstate = wxPyBeginAllowThreads();
44186 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44187
44188 wxPyEndAllowThreads(__tstate);
44189 if (PyErr_Occurred()) SWIG_fail;
44190 }
44191 {
44192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44193 }
44194 return resultobj;
44195 fail:
44196 return NULL;
44197 }
44198
44199
44200 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44201 PyObject *obj;
44202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44203 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44204 Py_INCREF(obj);
44205 return Py_BuildValue((char *)"");
44206 }
44207 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44208 PyObject *resultobj;
44209 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44210 wxRelationship arg2 ;
44211 wxWindow *arg3 = (wxWindow *) 0 ;
44212 wxEdge arg4 ;
44213 int arg5 = (int) 0 ;
44214 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44215 PyObject * obj0 = 0 ;
44216 PyObject * obj1 = 0 ;
44217 PyObject * obj2 = 0 ;
44218 PyObject * obj3 = 0 ;
44219 PyObject * obj4 = 0 ;
44220 PyObject * obj5 = 0 ;
44221 char *kwnames[] = {
44222 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44223 };
44224
44225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44227 if (SWIG_arg_fail(1)) SWIG_fail;
44228 {
44229 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44230 if (SWIG_arg_fail(2)) SWIG_fail;
44231 }
44232 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44233 if (SWIG_arg_fail(3)) SWIG_fail;
44234 {
44235 arg4 = (wxEdge)(SWIG_As_int(obj3));
44236 if (SWIG_arg_fail(4)) SWIG_fail;
44237 }
44238 if (obj4) {
44239 {
44240 arg5 = (int)(SWIG_As_int(obj4));
44241 if (SWIG_arg_fail(5)) SWIG_fail;
44242 }
44243 }
44244 if (obj5) {
44245 {
44246 arg6 = (int)(SWIG_As_int(obj5));
44247 if (SWIG_arg_fail(6)) SWIG_fail;
44248 }
44249 }
44250 {
44251 PyThreadState* __tstate = wxPyBeginAllowThreads();
44252 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44253
44254 wxPyEndAllowThreads(__tstate);
44255 if (PyErr_Occurred()) SWIG_fail;
44256 }
44257 Py_INCREF(Py_None); resultobj = Py_None;
44258 return resultobj;
44259 fail:
44260 return NULL;
44261 }
44262
44263
44264 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44265 PyObject *resultobj;
44266 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44267 wxWindow *arg2 = (wxWindow *) 0 ;
44268 int arg3 = (int) 0 ;
44269 PyObject * obj0 = 0 ;
44270 PyObject * obj1 = 0 ;
44271 PyObject * obj2 = 0 ;
44272 char *kwnames[] = {
44273 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44274 };
44275
44276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44278 if (SWIG_arg_fail(1)) SWIG_fail;
44279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44280 if (SWIG_arg_fail(2)) SWIG_fail;
44281 if (obj2) {
44282 {
44283 arg3 = (int)(SWIG_As_int(obj2));
44284 if (SWIG_arg_fail(3)) SWIG_fail;
44285 }
44286 }
44287 {
44288 PyThreadState* __tstate = wxPyBeginAllowThreads();
44289 (arg1)->LeftOf(arg2,arg3);
44290
44291 wxPyEndAllowThreads(__tstate);
44292 if (PyErr_Occurred()) SWIG_fail;
44293 }
44294 Py_INCREF(Py_None); resultobj = Py_None;
44295 return resultobj;
44296 fail:
44297 return NULL;
44298 }
44299
44300
44301 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44302 PyObject *resultobj;
44303 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44304 wxWindow *arg2 = (wxWindow *) 0 ;
44305 int arg3 = (int) 0 ;
44306 PyObject * obj0 = 0 ;
44307 PyObject * obj1 = 0 ;
44308 PyObject * obj2 = 0 ;
44309 char *kwnames[] = {
44310 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44311 };
44312
44313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44317 if (SWIG_arg_fail(2)) SWIG_fail;
44318 if (obj2) {
44319 {
44320 arg3 = (int)(SWIG_As_int(obj2));
44321 if (SWIG_arg_fail(3)) SWIG_fail;
44322 }
44323 }
44324 {
44325 PyThreadState* __tstate = wxPyBeginAllowThreads();
44326 (arg1)->RightOf(arg2,arg3);
44327
44328 wxPyEndAllowThreads(__tstate);
44329 if (PyErr_Occurred()) SWIG_fail;
44330 }
44331 Py_INCREF(Py_None); resultobj = Py_None;
44332 return resultobj;
44333 fail:
44334 return NULL;
44335 }
44336
44337
44338 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44339 PyObject *resultobj;
44340 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44341 wxWindow *arg2 = (wxWindow *) 0 ;
44342 int arg3 = (int) 0 ;
44343 PyObject * obj0 = 0 ;
44344 PyObject * obj1 = 0 ;
44345 PyObject * obj2 = 0 ;
44346 char *kwnames[] = {
44347 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44348 };
44349
44350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44352 if (SWIG_arg_fail(1)) SWIG_fail;
44353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44354 if (SWIG_arg_fail(2)) SWIG_fail;
44355 if (obj2) {
44356 {
44357 arg3 = (int)(SWIG_As_int(obj2));
44358 if (SWIG_arg_fail(3)) SWIG_fail;
44359 }
44360 }
44361 {
44362 PyThreadState* __tstate = wxPyBeginAllowThreads();
44363 (arg1)->Above(arg2,arg3);
44364
44365 wxPyEndAllowThreads(__tstate);
44366 if (PyErr_Occurred()) SWIG_fail;
44367 }
44368 Py_INCREF(Py_None); resultobj = Py_None;
44369 return resultobj;
44370 fail:
44371 return NULL;
44372 }
44373
44374
44375 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44376 PyObject *resultobj;
44377 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44378 wxWindow *arg2 = (wxWindow *) 0 ;
44379 int arg3 = (int) 0 ;
44380 PyObject * obj0 = 0 ;
44381 PyObject * obj1 = 0 ;
44382 PyObject * obj2 = 0 ;
44383 char *kwnames[] = {
44384 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44385 };
44386
44387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44389 if (SWIG_arg_fail(1)) SWIG_fail;
44390 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44391 if (SWIG_arg_fail(2)) SWIG_fail;
44392 if (obj2) {
44393 {
44394 arg3 = (int)(SWIG_As_int(obj2));
44395 if (SWIG_arg_fail(3)) SWIG_fail;
44396 }
44397 }
44398 {
44399 PyThreadState* __tstate = wxPyBeginAllowThreads();
44400 (arg1)->Below(arg2,arg3);
44401
44402 wxPyEndAllowThreads(__tstate);
44403 if (PyErr_Occurred()) SWIG_fail;
44404 }
44405 Py_INCREF(Py_None); resultobj = Py_None;
44406 return resultobj;
44407 fail:
44408 return NULL;
44409 }
44410
44411
44412 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44413 PyObject *resultobj;
44414 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44415 wxWindow *arg2 = (wxWindow *) 0 ;
44416 wxEdge arg3 ;
44417 int arg4 = (int) 0 ;
44418 PyObject * obj0 = 0 ;
44419 PyObject * obj1 = 0 ;
44420 PyObject * obj2 = 0 ;
44421 PyObject * obj3 = 0 ;
44422 char *kwnames[] = {
44423 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44424 };
44425
44426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44428 if (SWIG_arg_fail(1)) SWIG_fail;
44429 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44430 if (SWIG_arg_fail(2)) SWIG_fail;
44431 {
44432 arg3 = (wxEdge)(SWIG_As_int(obj2));
44433 if (SWIG_arg_fail(3)) SWIG_fail;
44434 }
44435 if (obj3) {
44436 {
44437 arg4 = (int)(SWIG_As_int(obj3));
44438 if (SWIG_arg_fail(4)) SWIG_fail;
44439 }
44440 }
44441 {
44442 PyThreadState* __tstate = wxPyBeginAllowThreads();
44443 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44444
44445 wxPyEndAllowThreads(__tstate);
44446 if (PyErr_Occurred()) SWIG_fail;
44447 }
44448 Py_INCREF(Py_None); resultobj = Py_None;
44449 return resultobj;
44450 fail:
44451 return NULL;
44452 }
44453
44454
44455 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44456 PyObject *resultobj;
44457 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44458 wxWindow *arg2 = (wxWindow *) 0 ;
44459 wxEdge arg3 ;
44460 int arg4 ;
44461 PyObject * obj0 = 0 ;
44462 PyObject * obj1 = 0 ;
44463 PyObject * obj2 = 0 ;
44464 PyObject * obj3 = 0 ;
44465 char *kwnames[] = {
44466 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44467 };
44468
44469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44471 if (SWIG_arg_fail(1)) SWIG_fail;
44472 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44473 if (SWIG_arg_fail(2)) SWIG_fail;
44474 {
44475 arg3 = (wxEdge)(SWIG_As_int(obj2));
44476 if (SWIG_arg_fail(3)) SWIG_fail;
44477 }
44478 {
44479 arg4 = (int)(SWIG_As_int(obj3));
44480 if (SWIG_arg_fail(4)) SWIG_fail;
44481 }
44482 {
44483 PyThreadState* __tstate = wxPyBeginAllowThreads();
44484 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44485
44486 wxPyEndAllowThreads(__tstate);
44487 if (PyErr_Occurred()) SWIG_fail;
44488 }
44489 Py_INCREF(Py_None); resultobj = Py_None;
44490 return resultobj;
44491 fail:
44492 return NULL;
44493 }
44494
44495
44496 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44497 PyObject *resultobj;
44498 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44499 int arg2 ;
44500 PyObject * obj0 = 0 ;
44501 PyObject * obj1 = 0 ;
44502 char *kwnames[] = {
44503 (char *) "self",(char *) "val", NULL
44504 };
44505
44506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44508 if (SWIG_arg_fail(1)) SWIG_fail;
44509 {
44510 arg2 = (int)(SWIG_As_int(obj1));
44511 if (SWIG_arg_fail(2)) SWIG_fail;
44512 }
44513 {
44514 PyThreadState* __tstate = wxPyBeginAllowThreads();
44515 (arg1)->Absolute(arg2);
44516
44517 wxPyEndAllowThreads(__tstate);
44518 if (PyErr_Occurred()) SWIG_fail;
44519 }
44520 Py_INCREF(Py_None); resultobj = Py_None;
44521 return resultobj;
44522 fail:
44523 return NULL;
44524 }
44525
44526
44527 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44528 PyObject *resultobj;
44529 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44530 PyObject * obj0 = 0 ;
44531 char *kwnames[] = {
44532 (char *) "self", NULL
44533 };
44534
44535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44537 if (SWIG_arg_fail(1)) SWIG_fail;
44538 {
44539 PyThreadState* __tstate = wxPyBeginAllowThreads();
44540 (arg1)->Unconstrained();
44541
44542 wxPyEndAllowThreads(__tstate);
44543 if (PyErr_Occurred()) SWIG_fail;
44544 }
44545 Py_INCREF(Py_None); resultobj = Py_None;
44546 return resultobj;
44547 fail:
44548 return NULL;
44549 }
44550
44551
44552 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44553 PyObject *resultobj;
44554 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44555 PyObject * obj0 = 0 ;
44556 char *kwnames[] = {
44557 (char *) "self", NULL
44558 };
44559
44560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44562 if (SWIG_arg_fail(1)) SWIG_fail;
44563 {
44564 PyThreadState* __tstate = wxPyBeginAllowThreads();
44565 (arg1)->AsIs();
44566
44567 wxPyEndAllowThreads(__tstate);
44568 if (PyErr_Occurred()) SWIG_fail;
44569 }
44570 Py_INCREF(Py_None); resultobj = Py_None;
44571 return resultobj;
44572 fail:
44573 return NULL;
44574 }
44575
44576
44577 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44578 PyObject *resultobj;
44579 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44580 wxWindow *result;
44581 PyObject * obj0 = 0 ;
44582 char *kwnames[] = {
44583 (char *) "self", NULL
44584 };
44585
44586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44588 if (SWIG_arg_fail(1)) SWIG_fail;
44589 {
44590 PyThreadState* __tstate = wxPyBeginAllowThreads();
44591 result = (wxWindow *)(arg1)->GetOtherWindow();
44592
44593 wxPyEndAllowThreads(__tstate);
44594 if (PyErr_Occurred()) SWIG_fail;
44595 }
44596 {
44597 resultobj = wxPyMake_wxObject(result, 0);
44598 }
44599 return resultobj;
44600 fail:
44601 return NULL;
44602 }
44603
44604
44605 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44606 PyObject *resultobj;
44607 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44608 wxEdge result;
44609 PyObject * obj0 = 0 ;
44610 char *kwnames[] = {
44611 (char *) "self", NULL
44612 };
44613
44614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44616 if (SWIG_arg_fail(1)) SWIG_fail;
44617 {
44618 PyThreadState* __tstate = wxPyBeginAllowThreads();
44619 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44620
44621 wxPyEndAllowThreads(__tstate);
44622 if (PyErr_Occurred()) SWIG_fail;
44623 }
44624 resultobj = SWIG_From_int((result));
44625 return resultobj;
44626 fail:
44627 return NULL;
44628 }
44629
44630
44631 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44632 PyObject *resultobj;
44633 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44634 wxEdge arg2 ;
44635 PyObject * obj0 = 0 ;
44636 PyObject * obj1 = 0 ;
44637 char *kwnames[] = {
44638 (char *) "self",(char *) "which", NULL
44639 };
44640
44641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44643 if (SWIG_arg_fail(1)) SWIG_fail;
44644 {
44645 arg2 = (wxEdge)(SWIG_As_int(obj1));
44646 if (SWIG_arg_fail(2)) SWIG_fail;
44647 }
44648 {
44649 PyThreadState* __tstate = wxPyBeginAllowThreads();
44650 (arg1)->SetEdge((wxEdge )arg2);
44651
44652 wxPyEndAllowThreads(__tstate);
44653 if (PyErr_Occurred()) SWIG_fail;
44654 }
44655 Py_INCREF(Py_None); resultobj = Py_None;
44656 return resultobj;
44657 fail:
44658 return NULL;
44659 }
44660
44661
44662 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44663 PyObject *resultobj;
44664 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44665 int arg2 ;
44666 PyObject * obj0 = 0 ;
44667 PyObject * obj1 = 0 ;
44668 char *kwnames[] = {
44669 (char *) "self",(char *) "v", NULL
44670 };
44671
44672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44674 if (SWIG_arg_fail(1)) SWIG_fail;
44675 {
44676 arg2 = (int)(SWIG_As_int(obj1));
44677 if (SWIG_arg_fail(2)) SWIG_fail;
44678 }
44679 {
44680 PyThreadState* __tstate = wxPyBeginAllowThreads();
44681 (arg1)->SetValue(arg2);
44682
44683 wxPyEndAllowThreads(__tstate);
44684 if (PyErr_Occurred()) SWIG_fail;
44685 }
44686 Py_INCREF(Py_None); resultobj = Py_None;
44687 return resultobj;
44688 fail:
44689 return NULL;
44690 }
44691
44692
44693 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44694 PyObject *resultobj;
44695 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44696 int result;
44697 PyObject * obj0 = 0 ;
44698 char *kwnames[] = {
44699 (char *) "self", NULL
44700 };
44701
44702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44704 if (SWIG_arg_fail(1)) SWIG_fail;
44705 {
44706 PyThreadState* __tstate = wxPyBeginAllowThreads();
44707 result = (int)(arg1)->GetMargin();
44708
44709 wxPyEndAllowThreads(__tstate);
44710 if (PyErr_Occurred()) SWIG_fail;
44711 }
44712 {
44713 resultobj = SWIG_From_int((int)(result));
44714 }
44715 return resultobj;
44716 fail:
44717 return NULL;
44718 }
44719
44720
44721 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44722 PyObject *resultobj;
44723 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44724 int arg2 ;
44725 PyObject * obj0 = 0 ;
44726 PyObject * obj1 = 0 ;
44727 char *kwnames[] = {
44728 (char *) "self",(char *) "m", NULL
44729 };
44730
44731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44733 if (SWIG_arg_fail(1)) SWIG_fail;
44734 {
44735 arg2 = (int)(SWIG_As_int(obj1));
44736 if (SWIG_arg_fail(2)) SWIG_fail;
44737 }
44738 {
44739 PyThreadState* __tstate = wxPyBeginAllowThreads();
44740 (arg1)->SetMargin(arg2);
44741
44742 wxPyEndAllowThreads(__tstate);
44743 if (PyErr_Occurred()) SWIG_fail;
44744 }
44745 Py_INCREF(Py_None); resultobj = Py_None;
44746 return resultobj;
44747 fail:
44748 return NULL;
44749 }
44750
44751
44752 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44753 PyObject *resultobj;
44754 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44755 int result;
44756 PyObject * obj0 = 0 ;
44757 char *kwnames[] = {
44758 (char *) "self", NULL
44759 };
44760
44761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44763 if (SWIG_arg_fail(1)) SWIG_fail;
44764 {
44765 PyThreadState* __tstate = wxPyBeginAllowThreads();
44766 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44767
44768 wxPyEndAllowThreads(__tstate);
44769 if (PyErr_Occurred()) SWIG_fail;
44770 }
44771 {
44772 resultobj = SWIG_From_int((int)(result));
44773 }
44774 return resultobj;
44775 fail:
44776 return NULL;
44777 }
44778
44779
44780 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44781 PyObject *resultobj;
44782 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44783 int result;
44784 PyObject * obj0 = 0 ;
44785 char *kwnames[] = {
44786 (char *) "self", NULL
44787 };
44788
44789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44791 if (SWIG_arg_fail(1)) SWIG_fail;
44792 {
44793 PyThreadState* __tstate = wxPyBeginAllowThreads();
44794 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44795
44796 wxPyEndAllowThreads(__tstate);
44797 if (PyErr_Occurred()) SWIG_fail;
44798 }
44799 {
44800 resultobj = SWIG_From_int((int)(result));
44801 }
44802 return resultobj;
44803 fail:
44804 return NULL;
44805 }
44806
44807
44808 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44809 PyObject *resultobj;
44810 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44811 int result;
44812 PyObject * obj0 = 0 ;
44813 char *kwnames[] = {
44814 (char *) "self", NULL
44815 };
44816
44817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44819 if (SWIG_arg_fail(1)) SWIG_fail;
44820 {
44821 PyThreadState* __tstate = wxPyBeginAllowThreads();
44822 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44823
44824 wxPyEndAllowThreads(__tstate);
44825 if (PyErr_Occurred()) SWIG_fail;
44826 }
44827 {
44828 resultobj = SWIG_From_int((int)(result));
44829 }
44830 return resultobj;
44831 fail:
44832 return NULL;
44833 }
44834
44835
44836 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44837 PyObject *resultobj;
44838 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44839 bool result;
44840 PyObject * obj0 = 0 ;
44841 char *kwnames[] = {
44842 (char *) "self", NULL
44843 };
44844
44845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44847 if (SWIG_arg_fail(1)) SWIG_fail;
44848 {
44849 PyThreadState* __tstate = wxPyBeginAllowThreads();
44850 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44851
44852 wxPyEndAllowThreads(__tstate);
44853 if (PyErr_Occurred()) SWIG_fail;
44854 }
44855 {
44856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44857 }
44858 return resultobj;
44859 fail:
44860 return NULL;
44861 }
44862
44863
44864 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44865 PyObject *resultobj;
44866 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44867 bool arg2 ;
44868 PyObject * obj0 = 0 ;
44869 PyObject * obj1 = 0 ;
44870 char *kwnames[] = {
44871 (char *) "self",(char *) "d", NULL
44872 };
44873
44874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44876 if (SWIG_arg_fail(1)) SWIG_fail;
44877 {
44878 arg2 = (bool)(SWIG_As_bool(obj1));
44879 if (SWIG_arg_fail(2)) SWIG_fail;
44880 }
44881 {
44882 PyThreadState* __tstate = wxPyBeginAllowThreads();
44883 (arg1)->SetDone(arg2);
44884
44885 wxPyEndAllowThreads(__tstate);
44886 if (PyErr_Occurred()) SWIG_fail;
44887 }
44888 Py_INCREF(Py_None); resultobj = Py_None;
44889 return resultobj;
44890 fail:
44891 return NULL;
44892 }
44893
44894
44895 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44896 PyObject *resultobj;
44897 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44898 wxRelationship result;
44899 PyObject * obj0 = 0 ;
44900 char *kwnames[] = {
44901 (char *) "self", NULL
44902 };
44903
44904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44906 if (SWIG_arg_fail(1)) SWIG_fail;
44907 {
44908 PyThreadState* __tstate = wxPyBeginAllowThreads();
44909 result = (wxRelationship)(arg1)->GetRelationship();
44910
44911 wxPyEndAllowThreads(__tstate);
44912 if (PyErr_Occurred()) SWIG_fail;
44913 }
44914 resultobj = SWIG_From_int((result));
44915 return resultobj;
44916 fail:
44917 return NULL;
44918 }
44919
44920
44921 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44922 PyObject *resultobj;
44923 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44924 wxRelationship arg2 ;
44925 PyObject * obj0 = 0 ;
44926 PyObject * obj1 = 0 ;
44927 char *kwnames[] = {
44928 (char *) "self",(char *) "r", NULL
44929 };
44930
44931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44933 if (SWIG_arg_fail(1)) SWIG_fail;
44934 {
44935 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44936 if (SWIG_arg_fail(2)) SWIG_fail;
44937 }
44938 {
44939 PyThreadState* __tstate = wxPyBeginAllowThreads();
44940 (arg1)->SetRelationship((wxRelationship )arg2);
44941
44942 wxPyEndAllowThreads(__tstate);
44943 if (PyErr_Occurred()) SWIG_fail;
44944 }
44945 Py_INCREF(Py_None); resultobj = Py_None;
44946 return resultobj;
44947 fail:
44948 return NULL;
44949 }
44950
44951
44952 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44953 PyObject *resultobj;
44954 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44955 wxWindow *arg2 = (wxWindow *) 0 ;
44956 bool result;
44957 PyObject * obj0 = 0 ;
44958 PyObject * obj1 = 0 ;
44959 char *kwnames[] = {
44960 (char *) "self",(char *) "otherW", NULL
44961 };
44962
44963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44965 if (SWIG_arg_fail(1)) SWIG_fail;
44966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44967 if (SWIG_arg_fail(2)) SWIG_fail;
44968 {
44969 PyThreadState* __tstate = wxPyBeginAllowThreads();
44970 result = (bool)(arg1)->ResetIfWin(arg2);
44971
44972 wxPyEndAllowThreads(__tstate);
44973 if (PyErr_Occurred()) SWIG_fail;
44974 }
44975 {
44976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44977 }
44978 return resultobj;
44979 fail:
44980 return NULL;
44981 }
44982
44983
44984 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44985 PyObject *resultobj;
44986 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44987 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44988 wxWindow *arg3 = (wxWindow *) 0 ;
44989 bool result;
44990 PyObject * obj0 = 0 ;
44991 PyObject * obj1 = 0 ;
44992 PyObject * obj2 = 0 ;
44993 char *kwnames[] = {
44994 (char *) "self",(char *) "constraints",(char *) "win", NULL
44995 };
44996
44997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44999 if (SWIG_arg_fail(1)) SWIG_fail;
45000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45001 if (SWIG_arg_fail(2)) SWIG_fail;
45002 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45003 if (SWIG_arg_fail(3)) SWIG_fail;
45004 {
45005 PyThreadState* __tstate = wxPyBeginAllowThreads();
45006 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45007
45008 wxPyEndAllowThreads(__tstate);
45009 if (PyErr_Occurred()) SWIG_fail;
45010 }
45011 {
45012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45013 }
45014 return resultobj;
45015 fail:
45016 return NULL;
45017 }
45018
45019
45020 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45021 PyObject *resultobj;
45022 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45023 wxEdge arg2 ;
45024 wxWindow *arg3 = (wxWindow *) 0 ;
45025 wxWindow *arg4 = (wxWindow *) 0 ;
45026 int result;
45027 PyObject * obj0 = 0 ;
45028 PyObject * obj1 = 0 ;
45029 PyObject * obj2 = 0 ;
45030 PyObject * obj3 = 0 ;
45031 char *kwnames[] = {
45032 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45033 };
45034
45035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45037 if (SWIG_arg_fail(1)) SWIG_fail;
45038 {
45039 arg2 = (wxEdge)(SWIG_As_int(obj1));
45040 if (SWIG_arg_fail(2)) SWIG_fail;
45041 }
45042 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45043 if (SWIG_arg_fail(3)) SWIG_fail;
45044 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45045 if (SWIG_arg_fail(4)) SWIG_fail;
45046 {
45047 PyThreadState* __tstate = wxPyBeginAllowThreads();
45048 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45049
45050 wxPyEndAllowThreads(__tstate);
45051 if (PyErr_Occurred()) SWIG_fail;
45052 }
45053 {
45054 resultobj = SWIG_From_int((int)(result));
45055 }
45056 return resultobj;
45057 fail:
45058 return NULL;
45059 }
45060
45061
45062 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45063 PyObject *obj;
45064 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45065 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45066 Py_INCREF(obj);
45067 return Py_BuildValue((char *)"");
45068 }
45069 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45070 PyObject *resultobj;
45071 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45072 wxIndividualLayoutConstraint *result;
45073 PyObject * obj0 = 0 ;
45074 char *kwnames[] = {
45075 (char *) "self", NULL
45076 };
45077
45078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45080 if (SWIG_arg_fail(1)) SWIG_fail;
45081 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45082
45083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45084 return resultobj;
45085 fail:
45086 return NULL;
45087 }
45088
45089
45090 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45091 PyObject *resultobj;
45092 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45093 wxIndividualLayoutConstraint *result;
45094 PyObject * obj0 = 0 ;
45095 char *kwnames[] = {
45096 (char *) "self", NULL
45097 };
45098
45099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45101 if (SWIG_arg_fail(1)) SWIG_fail;
45102 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45103
45104 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45105 return resultobj;
45106 fail:
45107 return NULL;
45108 }
45109
45110
45111 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45112 PyObject *resultobj;
45113 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45114 wxIndividualLayoutConstraint *result;
45115 PyObject * obj0 = 0 ;
45116 char *kwnames[] = {
45117 (char *) "self", NULL
45118 };
45119
45120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45122 if (SWIG_arg_fail(1)) SWIG_fail;
45123 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45124
45125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45126 return resultobj;
45127 fail:
45128 return NULL;
45129 }
45130
45131
45132 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45133 PyObject *resultobj;
45134 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45135 wxIndividualLayoutConstraint *result;
45136 PyObject * obj0 = 0 ;
45137 char *kwnames[] = {
45138 (char *) "self", NULL
45139 };
45140
45141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45143 if (SWIG_arg_fail(1)) SWIG_fail;
45144 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45145
45146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45147 return resultobj;
45148 fail:
45149 return NULL;
45150 }
45151
45152
45153 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45154 PyObject *resultobj;
45155 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45156 wxIndividualLayoutConstraint *result;
45157 PyObject * obj0 = 0 ;
45158 char *kwnames[] = {
45159 (char *) "self", NULL
45160 };
45161
45162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45164 if (SWIG_arg_fail(1)) SWIG_fail;
45165 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45166
45167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45168 return resultobj;
45169 fail:
45170 return NULL;
45171 }
45172
45173
45174 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45175 PyObject *resultobj;
45176 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45177 wxIndividualLayoutConstraint *result;
45178 PyObject * obj0 = 0 ;
45179 char *kwnames[] = {
45180 (char *) "self", NULL
45181 };
45182
45183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45185 if (SWIG_arg_fail(1)) SWIG_fail;
45186 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45187
45188 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45189 return resultobj;
45190 fail:
45191 return NULL;
45192 }
45193
45194
45195 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45196 PyObject *resultobj;
45197 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45198 wxIndividualLayoutConstraint *result;
45199 PyObject * obj0 = 0 ;
45200 char *kwnames[] = {
45201 (char *) "self", NULL
45202 };
45203
45204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45206 if (SWIG_arg_fail(1)) SWIG_fail;
45207 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45208
45209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45210 return resultobj;
45211 fail:
45212 return NULL;
45213 }
45214
45215
45216 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45217 PyObject *resultobj;
45218 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45219 wxIndividualLayoutConstraint *result;
45220 PyObject * obj0 = 0 ;
45221 char *kwnames[] = {
45222 (char *) "self", NULL
45223 };
45224
45225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45227 if (SWIG_arg_fail(1)) SWIG_fail;
45228 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45229
45230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45231 return resultobj;
45232 fail:
45233 return NULL;
45234 }
45235
45236
45237 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45238 PyObject *resultobj;
45239 wxLayoutConstraints *result;
45240 char *kwnames[] = {
45241 NULL
45242 };
45243
45244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45245 {
45246 PyThreadState* __tstate = wxPyBeginAllowThreads();
45247 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45248
45249 wxPyEndAllowThreads(__tstate);
45250 if (PyErr_Occurred()) SWIG_fail;
45251 }
45252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45253 return resultobj;
45254 fail:
45255 return NULL;
45256 }
45257
45258
45259 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45260 PyObject *resultobj;
45261 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45262 wxWindow *arg2 = (wxWindow *) 0 ;
45263 int *arg3 = (int *) 0 ;
45264 bool result;
45265 int temp3 ;
45266 int res3 = 0 ;
45267 PyObject * obj0 = 0 ;
45268 PyObject * obj1 = 0 ;
45269 char *kwnames[] = {
45270 (char *) "self",(char *) "win", NULL
45271 };
45272
45273 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45276 if (SWIG_arg_fail(1)) SWIG_fail;
45277 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45278 if (SWIG_arg_fail(2)) SWIG_fail;
45279 {
45280 PyThreadState* __tstate = wxPyBeginAllowThreads();
45281 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45282
45283 wxPyEndAllowThreads(__tstate);
45284 if (PyErr_Occurred()) SWIG_fail;
45285 }
45286 {
45287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45288 }
45289 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45290 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45291 return resultobj;
45292 fail:
45293 return NULL;
45294 }
45295
45296
45297 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45298 PyObject *resultobj;
45299 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45300 bool result;
45301 PyObject * obj0 = 0 ;
45302 char *kwnames[] = {
45303 (char *) "self", NULL
45304 };
45305
45306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45308 if (SWIG_arg_fail(1)) SWIG_fail;
45309 {
45310 PyThreadState* __tstate = wxPyBeginAllowThreads();
45311 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45312
45313 wxPyEndAllowThreads(__tstate);
45314 if (PyErr_Occurred()) SWIG_fail;
45315 }
45316 {
45317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45318 }
45319 return resultobj;
45320 fail:
45321 return NULL;
45322 }
45323
45324
45325 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45326 PyObject *obj;
45327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45328 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45329 Py_INCREF(obj);
45330 return Py_BuildValue((char *)"");
45331 }
45332 static PyMethodDef SwigMethods[] = {
45333 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45334 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45335 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45338 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45359 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45372 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45387 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45441 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45469 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45488 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45490 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45498 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45499 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45511 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45523 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45527 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45533 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45543 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45553 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45560 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45619 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45625 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45637 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45640 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45642 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45644 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45646 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45648 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45650 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45652 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45654 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45656 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45658 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45660 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45662 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45664 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45678 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45696 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45699 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45702 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45714 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45719 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45725 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45731 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45794 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45801 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45837 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45840 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45843 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45845 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45847 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45853 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45855 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45857 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45860 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45864 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45867 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45870 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45872 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45877 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45885 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45889 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45892 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45894 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45898 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45915 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45917 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45920 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45922 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45926 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45930 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45941 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45944 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45947 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45951 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45958 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45963 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45968 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45972 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46017 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46037 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46044 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46048 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46058 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46230 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46271 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46286 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46289 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46344 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46371 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46415 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46423 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46442 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46443 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46480 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46510 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46513 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46517 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46520 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46530 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46542 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46554 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46564 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46574 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46588 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46595 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46596 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46597 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46598 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46599 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46604 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46631 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46643 { NULL, NULL, 0, NULL }
46644 };
46645
46646
46647 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46648
46649 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46650 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46651 }
46652 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46653 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46654 }
46655 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46656 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46657 }
46658 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46659 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46660 }
46661 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46662 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46663 }
46664 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46665 return (void *)((wxSizer *) ((wxGridSizer *) x));
46666 }
46667 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46668 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46669 }
46670 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46671 return (void *)((wxSizer *) ((wxPySizer *) x));
46672 }
46673 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46674 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46675 }
46676 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46677 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46678 }
46679 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46680 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46681 }
46682 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46683 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46684 }
46685 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46686 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46687 }
46688 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46689 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46690 }
46691 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46692 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46693 }
46694 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46695 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46696 }
46697 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46698 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46699 }
46700 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46701 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46702 }
46703 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46704 return (void *)((wxEvent *) ((wxPyEvent *) x));
46705 }
46706 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46707 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46708 }
46709 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46710 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46711 }
46712 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46713 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46714 }
46715 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46716 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46717 }
46718 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46719 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46720 }
46721 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46722 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46723 }
46724 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46725 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46726 }
46727 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46728 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46729 }
46730 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46731 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46732 }
46733 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46734 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46735 }
46736 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46737 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46738 }
46739 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46740 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46741 }
46742 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46743 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46744 }
46745 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46746 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46747 }
46748 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46749 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46750 }
46751 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46752 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46753 }
46754 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46755 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46756 }
46757 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46758 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46759 }
46760 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46761 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46762 }
46763 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46764 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46765 }
46766 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46767 return (void *)((wxEvent *) ((wxShowEvent *) x));
46768 }
46769 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46770 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46771 }
46772 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46773 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46774 }
46775 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46776 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46777 }
46778 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46779 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46780 }
46781 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46782 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46783 }
46784 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46785 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46786 }
46787 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46788 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46789 }
46790 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46791 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46792 }
46793 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46794 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46795 }
46796 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46797 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46798 }
46799 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46800 return (void *)((wxControl *) ((wxControlWithItems *) x));
46801 }
46802 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46803 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46804 }
46805 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46806 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46807 }
46808 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46809 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46810 }
46811 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46812 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46813 }
46814 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46815 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46816 }
46817 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46818 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46819 }
46820 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46821 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46822 }
46823 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46824 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46825 }
46826 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46827 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46828 }
46829 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46830 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46831 }
46832 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46833 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46834 }
46835 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46836 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46837 }
46838 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46839 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46840 }
46841 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46842 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46843 }
46844 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46845 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46846 }
46847 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46848 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46849 }
46850 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46851 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46852 }
46853 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46854 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46855 }
46856 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46857 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46858 }
46859 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46860 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46861 }
46862 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46863 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46864 }
46865 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46866 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46867 }
46868 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46869 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46870 }
46871 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46872 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46873 }
46874 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46875 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46876 }
46877 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46878 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46879 }
46880 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46881 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46882 }
46883 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46884 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46885 }
46886 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46887 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46888 }
46889 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46890 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46891 }
46892 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46893 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46894 }
46895 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46896 return (void *)((wxObject *) ((wxSizerItem *) x));
46897 }
46898 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46899 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46900 }
46901 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46902 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46903 }
46904 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46905 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46906 }
46907 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46908 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46909 }
46910 static void *_p_wxSizerTo_p_wxObject(void *x) {
46911 return (void *)((wxObject *) ((wxSizer *) x));
46912 }
46913 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46914 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46915 }
46916 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46917 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46918 }
46919 static void *_p_wxEventTo_p_wxObject(void *x) {
46920 return (void *)((wxObject *) ((wxEvent *) x));
46921 }
46922 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46923 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46924 }
46925 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46926 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46927 }
46928 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46929 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46930 }
46931 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46932 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46933 }
46934 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46935 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46936 }
46937 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46938 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46939 }
46940 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46941 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46942 }
46943 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46944 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46945 }
46946 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46947 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46948 }
46949 static void *_p_wxControlTo_p_wxObject(void *x) {
46950 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46951 }
46952 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46953 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46954 }
46955 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46956 return (void *)((wxObject *) ((wxFSFile *) x));
46957 }
46958 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46959 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46960 }
46961 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46962 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46963 }
46964 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46965 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46966 }
46967 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46968 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46969 }
46970 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46971 return (void *)((wxObject *) ((wxMenuItem *) x));
46972 }
46973 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46974 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46975 }
46976 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46977 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46978 }
46979 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46980 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46981 }
46982 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46983 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46984 }
46985 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46986 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46987 }
46988 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46989 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46990 }
46991 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46992 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46993 }
46994 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46995 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46996 }
46997 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46998 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46999 }
47000 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47001 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47002 }
47003 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47004 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47005 }
47006 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47007 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47008 }
47009 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47010 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47011 }
47012 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47013 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47014 }
47015 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47016 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47017 }
47018 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47019 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47020 }
47021 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47022 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47023 }
47024 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47025 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47026 }
47027 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47028 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47029 }
47030 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47031 return (void *)((wxObject *) ((wxImageHandler *) x));
47032 }
47033 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47034 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47035 }
47036 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47037 return (void *)((wxObject *) ((wxEvtHandler *) x));
47038 }
47039 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47040 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47041 }
47042 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47043 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47044 }
47045 static void *_p_wxImageTo_p_wxObject(void *x) {
47046 return (void *)((wxObject *) ((wxImage *) x));
47047 }
47048 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47049 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47050 }
47051 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47052 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47053 }
47054 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47055 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47056 }
47057 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47058 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47059 }
47060 static void *_p_wxWindowTo_p_wxObject(void *x) {
47061 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47062 }
47063 static void *_p_wxMenuTo_p_wxObject(void *x) {
47064 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47065 }
47066 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47067 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47068 }
47069 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47070 return (void *)((wxObject *) ((wxFileSystem *) x));
47071 }
47072 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47073 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47074 }
47075 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47076 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47077 }
47078 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47079 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47080 }
47081 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47082 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47083 }
47084 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47085 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47086 }
47087 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47088 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47089 }
47090 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47091 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47092 }
47093 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47094 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47095 }
47096 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47097 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47098 }
47099 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47100 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47101 }
47102 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47103 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47104 }
47105 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47106 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47107 }
47108 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47109 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47110 }
47111 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47112 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47113 }
47114 static void *_p_wxControlTo_p_wxWindow(void *x) {
47115 return (void *)((wxWindow *) ((wxControl *) x));
47116 }
47117 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47118 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47119 }
47120 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47121 return (void *)((wxWindow *) ((wxMenuBar *) x));
47122 }
47123 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47124 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47125 }
47126 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47127 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47128 }
47129 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47130 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47131 }
47132 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47133 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47134 }
47135 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47136 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47137 }
47138 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47139 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47140 }
47141 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47142 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47143 }
47144 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47145 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47146 }
47147 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47148 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47149 }
47150 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47151 return (void *)((wxValidator *) ((wxPyValidator *) x));
47152 }
47153 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}};
47154 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}};
47155 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}};
47156 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}};
47157 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}};
47158 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}};
47159 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}};
47160 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}};
47161 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}};
47162 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}};
47163 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}};
47164 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}};
47165 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}};
47166 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}};
47167 static swig_type_info _swigt__p_buffer[] = {{"_p_buffer", 0, "buffer *", 0, 0, 0, 0},{"_p_buffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47168 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}};
47169 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}};
47170 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}};
47171 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}};
47172 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}};
47173 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}};
47174 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}};
47175 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}};
47176 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}};
47177 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}};
47178 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}};
47179 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}};
47180 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}};
47181 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}};
47182 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}};
47183 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}};
47184 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}};
47185 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}};
47186 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}};
47187 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}};
47188 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}};
47189 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}};
47190 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}};
47191 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}};
47192 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}};
47193 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}};
47194 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}};
47195 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}};
47196 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}};
47197 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}};
47198 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}};
47199 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}};
47200 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}};
47201 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}};
47202 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}};
47203 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}};
47204 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}};
47205 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}};
47206 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}};
47207 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}};
47208 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}};
47209 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}};
47210 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}};
47211 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}};
47212 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}};
47213 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}};
47214 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}};
47215 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}};
47216 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}};
47217 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}};
47218 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}};
47219 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}};
47220 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}};
47221 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}};
47222 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}};
47223 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}};
47224 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}};
47225 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}};
47226 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}};
47227 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}};
47228 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}};
47229 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}};
47230 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}};
47231 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}};
47232 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}};
47233 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}};
47234 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}};
47235 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}};
47236 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}};
47237 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}};
47238 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}};
47239 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}};
47240 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}};
47241 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}};
47242 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}};
47243 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}};
47244 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}};
47245 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}};
47246 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}};
47247 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}};
47248 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}};
47249 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}};
47250 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}};
47251 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}};
47252 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}};
47253 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}};
47254 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}};
47255 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}};
47256 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}};
47257 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}};
47258 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}};
47259 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}};
47260 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}};
47261 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}};
47262 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}};
47263 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}};
47264 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}};
47265 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}};
47266 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}};
47267 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}};
47268 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}};
47269 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}};
47270 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}};
47271 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}};
47272 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}};
47273 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}};
47274 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}};
47275 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}};
47276 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}};
47277 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}};
47278 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}};
47279 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}};
47280 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}};
47281
47282 static swig_type_info *swig_types_initial[] = {
47283 _swigt__p_wxLayoutConstraints,
47284 _swigt__p_wxRealPoint,
47285 _swigt__p_wxSizerItem,
47286 _swigt__p_wxGBSizerItem,
47287 _swigt__p_wxScrollEvent,
47288 _swigt__p_wxEventLoop,
47289 _swigt__p_wxIndividualLayoutConstraint,
47290 _swigt__p_wxSizer,
47291 _swigt__p_wxBoxSizer,
47292 _swigt__p_wxStaticBoxSizer,
47293 _swigt__p_wxGridBagSizer,
47294 _swigt__p_wxAcceleratorEntry,
47295 _swigt__p_wxUpdateUIEvent,
47296 _swigt__p_wxEvent,
47297 _swigt__p_buffer,
47298 _swigt__p_wxMenu,
47299 _swigt__p_wxGridSizer,
47300 _swigt__p_wxFlexGridSizer,
47301 _swigt__p_wxInitDialogEvent,
47302 _swigt__p_wxItemContainer,
47303 _swigt__p_wxNcPaintEvent,
47304 _swigt__p_wxPaintEvent,
47305 _swigt__p_wxSysColourChangedEvent,
47306 _swigt__p_wxMouseCaptureChangedEvent,
47307 _swigt__p_wxDisplayChangedEvent,
47308 _swigt__p_wxPaletteChangedEvent,
47309 _swigt__p_wxControl,
47310 _swigt__p_wxFont,
47311 _swigt__p_wxMenuBarBase,
47312 _swigt__p_wxSetCursorEvent,
47313 _swigt__p_wxFSFile,
47314 _swigt__p_wxCaret,
47315 _swigt__ptrdiff_t,
47316 _swigt__std__ptrdiff_t,
47317 _swigt__p_wxRegion,
47318 _swigt__p_wxPoint2D,
47319 _swigt__p_int,
47320 _swigt__p_wxSize,
47321 _swigt__p_wxDC,
47322 _swigt__p_wxPySizer,
47323 _swigt__p_wxVisualAttributes,
47324 _swigt__p_wxNotifyEvent,
47325 _swigt__p_wxPyEvent,
47326 _swigt__p_wxPropagationDisabler,
47327 _swigt__p_form_ops_t,
47328 _swigt__p_wxAppTraits,
47329 _swigt__p_wxArrayString,
47330 _swigt__p_wxShowEvent,
47331 _swigt__p_wxToolTip,
47332 _swigt__p_wxMoveEvent,
47333 _swigt__p_wxSizeEvent,
47334 _swigt__p_wxActivateEvent,
47335 _swigt__p_wxIconizeEvent,
47336 _swigt__p_wxMaximizeEvent,
47337 _swigt__p_wxQueryNewPaletteEvent,
47338 _swigt__p_wxWindowCreateEvent,
47339 _swigt__p_wxIdleEvent,
47340 _swigt__p_wxDateEvent,
47341 _swigt__p_wxMenuItem,
47342 _swigt__p_wxStaticBox,
47343 _swigt__p_long,
47344 _swigt__p_wxDuplexMode,
47345 _swigt__p_wxTIFFHandler,
47346 _swigt__p_wxXPMHandler,
47347 _swigt__p_wxPNMHandler,
47348 _swigt__p_wxJPEGHandler,
47349 _swigt__p_wxPCXHandler,
47350 _swigt__p_wxGIFHandler,
47351 _swigt__p_wxPNGHandler,
47352 _swigt__p_wxANIHandler,
47353 _swigt__p_wxMemoryFSHandler,
47354 _swigt__p_wxZipFSHandler,
47355 _swigt__p_wxInternetFSHandler,
47356 _swigt__p_wxPyFileSystemHandler,
47357 _swigt__p_wxEvtHandler,
47358 _swigt__p_wxCURHandler,
47359 _swigt__p_wxICOHandler,
47360 _swigt__p_wxBMPHandler,
47361 _swigt__p_wxImageHandler,
47362 _swigt__p_wxFileSystemHandler,
47363 _swigt__p_wxRect,
47364 _swigt__p_wxButton,
47365 _swigt__p_wxGBSpan,
47366 _swigt__p_wxPropagateOnce,
47367 _swigt__p_wxAcceleratorTable,
47368 _swigt__p_wxStdDialogButtonSizer,
47369 _swigt__p_char,
47370 _swigt__p_wxGBPosition,
47371 _swigt__p_wxImage,
47372 _swigt__p_wxFrame,
47373 _swigt__p_wxScrollWinEvent,
47374 _swigt__p_wxPaperSize,
47375 _swigt__p_wxImageHistogram,
47376 _swigt__p_wxPoint,
47377 _swigt__p_wxCursor,
47378 _swigt__p_wxObject,
47379 _swigt__p_wxInputStream,
47380 _swigt__p_wxOutputStream,
47381 _swigt__p_wxPyInputStream,
47382 _swigt__p_wxDateTime,
47383 _swigt__p_wxKeyEvent,
47384 _swigt__p_wxNavigationKeyEvent,
47385 _swigt__p_wxWindowDestroyEvent,
47386 _swigt__p_unsigned_long,
47387 _swigt__p_wxWindow,
47388 _swigt__p_wxMenuBar,
47389 _swigt__p_wxFileSystem,
47390 _swigt__p_wxBitmap,
47391 _swigt__unsigned_int,
47392 _swigt__p_unsigned_int,
47393 _swigt__p_wxMenuEvent,
47394 _swigt__p_wxContextMenuEvent,
47395 _swigt__p_unsigned_char,
47396 _swigt__p_wxEraseEvent,
47397 _swigt__p_wxMouseEvent,
47398 _swigt__p_wxCloseEvent,
47399 _swigt__p_wxPyApp,
47400 _swigt__p_wxCommandEvent,
47401 _swigt__p_wxPyCommandEvent,
47402 _swigt__p_wxPyDropTarget,
47403 _swigt__p_wxQuantize,
47404 _swigt__p_wxFocusEvent,
47405 _swigt__p_wxChildFocusEvent,
47406 _swigt__p_wxDropFilesEvent,
47407 _swigt__p_wxControlWithItems,
47408 _swigt__p_wxColour,
47409 _swigt__p_wxValidator,
47410 _swigt__p_wxPyValidator,
47411 0
47412 };
47413
47414
47415 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47416
47417 static swig_const_info swig_const_table[] = {
47418 {0, 0, 0, 0.0, 0, 0}};
47419
47420 #ifdef __cplusplus
47421 }
47422 #endif
47423
47424
47425 #ifdef __cplusplus
47426 extern "C" {
47427 #endif
47428
47429 /* Python-specific SWIG API */
47430 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47431 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47432 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47433
47434 /* -----------------------------------------------------------------------------
47435 * global variable support code.
47436 * ----------------------------------------------------------------------------- */
47437
47438 typedef struct swig_globalvar {
47439 char *name; /* Name of global variable */
47440 PyObject *(*get_attr)(); /* Return the current value */
47441 int (*set_attr)(PyObject *); /* Set the value */
47442 struct swig_globalvar *next;
47443 } swig_globalvar;
47444
47445 typedef struct swig_varlinkobject {
47446 PyObject_HEAD
47447 swig_globalvar *vars;
47448 } swig_varlinkobject;
47449
47450 static PyObject *
47451 swig_varlink_repr(swig_varlinkobject *v) {
47452 v = v;
47453 return PyString_FromString("<Swig global variables>");
47454 }
47455
47456 static int
47457 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47458 swig_globalvar *var;
47459 flags = flags;
47460 fprintf(fp,"Swig global variables { ");
47461 for (var = v->vars; var; var=var->next) {
47462 fprintf(fp,"%s", var->name);
47463 if (var->next) fprintf(fp,", ");
47464 }
47465 fprintf(fp," }\n");
47466 return 0;
47467 }
47468
47469 static PyObject *
47470 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47471 swig_globalvar *var = v->vars;
47472 while (var) {
47473 if (strcmp(var->name,n) == 0) {
47474 return (*var->get_attr)();
47475 }
47476 var = var->next;
47477 }
47478 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47479 return NULL;
47480 }
47481
47482 static int
47483 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47484 swig_globalvar *var = v->vars;
47485 while (var) {
47486 if (strcmp(var->name,n) == 0) {
47487 return (*var->set_attr)(p);
47488 }
47489 var = var->next;
47490 }
47491 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47492 return 1;
47493 }
47494
47495 static PyTypeObject varlinktype = {
47496 PyObject_HEAD_INIT(0)
47497 0, /* Number of items in variable part (ob_size) */
47498 (char *)"swigvarlink", /* Type name (tp_name) */
47499 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47500 0, /* Itemsize (tp_itemsize) */
47501 0, /* Deallocator (tp_dealloc) */
47502 (printfunc) swig_varlink_print, /* Print (tp_print) */
47503 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47504 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47505 0, /* tp_compare */
47506 (reprfunc) swig_varlink_repr, /* tp_repr */
47507 0, /* tp_as_number */
47508 0, /* tp_as_sequence */
47509 0, /* tp_as_mapping */
47510 0, /* tp_hash */
47511 0, /* tp_call */
47512 0, /* tp_str */
47513 0, /* tp_getattro */
47514 0, /* tp_setattro */
47515 0, /* tp_as_buffer */
47516 0, /* tp_flags */
47517 0, /* tp_doc */
47518 #if PY_VERSION_HEX >= 0x02000000
47519 0, /* tp_traverse */
47520 0, /* tp_clear */
47521 #endif
47522 #if PY_VERSION_HEX >= 0x02010000
47523 0, /* tp_richcompare */
47524 0, /* tp_weaklistoffset */
47525 #endif
47526 #if PY_VERSION_HEX >= 0x02020000
47527 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47528 #endif
47529 #if PY_VERSION_HEX >= 0x02030000
47530 0, /* tp_del */
47531 #endif
47532 #ifdef COUNT_ALLOCS
47533 0,0,0,0 /* tp_alloc -> tp_next */
47534 #endif
47535 };
47536
47537 /* Create a variable linking object for use later */
47538 static PyObject *
47539 SWIG_Python_newvarlink(void) {
47540 swig_varlinkobject *result = 0;
47541 result = PyMem_NEW(swig_varlinkobject,1);
47542 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47543 result->ob_type = &varlinktype;
47544 result->vars = 0;
47545 result->ob_refcnt = 0;
47546 Py_XINCREF((PyObject *) result);
47547 return ((PyObject*) result);
47548 }
47549
47550 static void
47551 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47552 swig_varlinkobject *v;
47553 swig_globalvar *gv;
47554 v= (swig_varlinkobject *) p;
47555 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47556 gv->name = (char *) malloc(strlen(name)+1);
47557 strcpy(gv->name,name);
47558 gv->get_attr = get_attr;
47559 gv->set_attr = set_attr;
47560 gv->next = v->vars;
47561 v->vars = gv;
47562 }
47563
47564 /* -----------------------------------------------------------------------------
47565 * constants/methods manipulation
47566 * ----------------------------------------------------------------------------- */
47567
47568 /* Install Constants */
47569 static void
47570 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47571 PyObject *obj = 0;
47572 size_t i;
47573 for (i = 0; constants[i].type; i++) {
47574 switch(constants[i].type) {
47575 case SWIG_PY_INT:
47576 obj = PyInt_FromLong(constants[i].lvalue);
47577 break;
47578 case SWIG_PY_FLOAT:
47579 obj = PyFloat_FromDouble(constants[i].dvalue);
47580 break;
47581 case SWIG_PY_STRING:
47582 if (constants[i].pvalue) {
47583 obj = PyString_FromString((char *) constants[i].pvalue);
47584 } else {
47585 Py_INCREF(Py_None);
47586 obj = Py_None;
47587 }
47588 break;
47589 case SWIG_PY_POINTER:
47590 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47591 break;
47592 case SWIG_PY_BINARY:
47593 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47594 break;
47595 default:
47596 obj = 0;
47597 break;
47598 }
47599 if (obj) {
47600 PyDict_SetItemString(d,constants[i].name,obj);
47601 Py_DECREF(obj);
47602 }
47603 }
47604 }
47605
47606 /* -----------------------------------------------------------------------------*/
47607 /* Fix SwigMethods to carry the callback ptrs when needed */
47608 /* -----------------------------------------------------------------------------*/
47609
47610 static void
47611 SWIG_Python_FixMethods(PyMethodDef *methods,
47612 swig_const_info *const_table,
47613 swig_type_info **types,
47614 swig_type_info **types_initial) {
47615 size_t i;
47616 for (i = 0; methods[i].ml_name; ++i) {
47617 char *c = methods[i].ml_doc;
47618 if (c && (c = strstr(c, "swig_ptr: "))) {
47619 int j;
47620 swig_const_info *ci = 0;
47621 char *name = c + 10;
47622 for (j = 0; const_table[j].type; j++) {
47623 if (strncmp(const_table[j].name, name,
47624 strlen(const_table[j].name)) == 0) {
47625 ci = &(const_table[j]);
47626 break;
47627 }
47628 }
47629 if (ci) {
47630 size_t shift = (ci->ptype) - types;
47631 swig_type_info *ty = types_initial[shift];
47632 size_t ldoc = (c - methods[i].ml_doc);
47633 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47634 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47635 char *buff = ndoc;
47636 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47637 strncpy(buff, methods[i].ml_doc, ldoc);
47638 buff += ldoc;
47639 strncpy(buff, "swig_ptr: ", 10);
47640 buff += 10;
47641 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47642 methods[i].ml_doc = ndoc;
47643 }
47644 }
47645 }
47646 }
47647
47648 /* -----------------------------------------------------------------------------*
47649 * Initialize type list
47650 * -----------------------------------------------------------------------------*/
47651
47652 #if PY_MAJOR_VERSION < 2
47653 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47654 is copied out of Python/modsupport.c in python version 2.3.4 */
47655 static int
47656 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47657 {
47658 PyObject *dict;
47659 if (!PyModule_Check(m)) {
47660 PyErr_SetString(PyExc_TypeError,
47661 "PyModule_AddObject() needs module as first arg");
47662 return -1;
47663 }
47664 if (!o) {
47665 PyErr_SetString(PyExc_TypeError,
47666 "PyModule_AddObject() needs non-NULL value");
47667 return -1;
47668 }
47669
47670 dict = PyModule_GetDict(m);
47671 if (dict == NULL) {
47672 /* Internal error -- modules must have a dict! */
47673 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47674 PyModule_GetName(m));
47675 return -1;
47676 }
47677 if (PyDict_SetItemString(dict, name, o))
47678 return -1;
47679 Py_DECREF(o);
47680 return 0;
47681 }
47682 #endif
47683
47684 static swig_type_info **
47685 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47686 static PyMethodDef swig_empty_runtime_method_table[] = {
47687 {
47688 NULL, NULL, 0, NULL
47689 }
47690 };/* Sentinel */
47691
47692 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47693 swig_empty_runtime_method_table);
47694 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47695 if (pointer && module) {
47696 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47697 }
47698 return type_list_handle;
47699 }
47700
47701 static swig_type_info **
47702 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47703 swig_type_info **type_pointer;
47704
47705 /* first check if module already created */
47706 type_pointer = SWIG_Python_GetTypeListHandle();
47707 if (type_pointer) {
47708 return type_pointer;
47709 } else {
47710 /* create a new module and variable */
47711 return SWIG_Python_SetTypeListHandle(type_list_handle);
47712 }
47713 }
47714
47715 #ifdef __cplusplus
47716 }
47717 #endif
47718
47719 /* -----------------------------------------------------------------------------*
47720 * Partial Init method
47721 * -----------------------------------------------------------------------------*/
47722
47723 #ifdef SWIG_LINK_RUNTIME
47724 #ifdef __cplusplus
47725 extern "C"
47726 #endif
47727 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47728 #endif
47729
47730 #ifdef __cplusplus
47731 extern "C"
47732 #endif
47733 SWIGEXPORT(void) SWIG_init(void) {
47734 static PyObject *SWIG_globals = 0;
47735 static int typeinit = 0;
47736 PyObject *m, *d;
47737 int i;
47738 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47739
47740 /* Fix SwigMethods to carry the callback ptrs when needed */
47741 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47742
47743 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47744 d = PyModule_GetDict(m);
47745
47746 if (!typeinit) {
47747 #ifdef SWIG_LINK_RUNTIME
47748 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47749 #else
47750 # ifndef SWIG_STATIC_RUNTIME
47751 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47752 # endif
47753 #endif
47754 for (i = 0; swig_types_initial[i]; i++) {
47755 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47756 }
47757 typeinit = 1;
47758 }
47759 SWIG_InstallConstants(d,swig_const_table);
47760
47761
47762 #ifndef wxPyUSE_EXPORT
47763 // Make our API structure a CObject so other modules can import it
47764 // from this module.
47765 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47766 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47767 Py_XDECREF(cobj);
47768 #endif
47769
47770 {
47771 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49176 }
49177 {
49178 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49179 }
49180 {
49181 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49182 }
49183 {
49184 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49185 }
49186 {
49187 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49188 }
49189 {
49190 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49434 }
49435 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49436 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49437 {
49438 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49439 }
49440 {
49441 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49442 }
49443 {
49444 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49445 }
49446 {
49447 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49448 }
49449 {
49450 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49451 }
49452 {
49453 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49460 }
49461 {
49462 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49463 }
49464 {
49465 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49466 }
49467 {
49468 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49469 }
49470 {
49471 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49472 }
49473 {
49474 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49475 }
49476 {
49477 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49478 }
49479 {
49480 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49481 }
49482 {
49483 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49484 }
49485 {
49486 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49487 }
49488 {
49489 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49490 }
49491 {
49492 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49514 }
49515 {
49516 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49517 }
49518 {
49519 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49520 }
49521 {
49522 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49529 }
49530 {
49531 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49532 }
49533 {
49534 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49535 }
49536 {
49537 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49538 }
49539 {
49540 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49541 }
49542 {
49543 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49544 }
49545 {
49546 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49547 }
49548 {
49549 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49550 }
49551 {
49552 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49553 }
49554 {
49555 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49556 }
49557 {
49558 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49559 }
49560 {
49561 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49562 }
49563 {
49564 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49565 }
49566 {
49567 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49568 }
49569 {
49570 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49571 }
49572 {
49573 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49574 }
49575 {
49576 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49577 }
49578 {
49579 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49580 }
49581 {
49582 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49583 }
49584 {
49585 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49586 }
49587 {
49588 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49589 }
49590 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49591 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49592 {
49593 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49594 }
49595 {
49596 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49597 }
49598 {
49599 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49600 }
49601
49602 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49603
49604
49605 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49606
49607 {
49608 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49609 }
49610 {
49611 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49612 }
49613 {
49614 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49615 }
49616 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49617 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49618 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49619 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49620 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49621 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49622 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49623 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49624 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49625 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49626 {
49627 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49628 }
49629 {
49630 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49631 }
49632 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49633 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49634 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49635 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49636 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49637 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49638 {
49639 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49640 }
49641 {
49642 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49643 }
49644 {
49645 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49646 }
49647 {
49648 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49649 }
49650 {
49651 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49652 }
49653 {
49654 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49655 }
49656 {
49657 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49658 }
49659 {
49660 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49661 }
49662 {
49663 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49664 }
49665 {
49666 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49667 }
49668 {
49669 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49670 }
49671 {
49672 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49673 }
49674 {
49675 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49676 }
49677 {
49678 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49679 }
49680 {
49681 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49682 }
49683 {
49684 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49685 }
49686 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49687 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49688 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49689 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49690 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49691 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49692 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49693 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49694 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49695 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49696 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49697 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49698 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49699 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49700 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49701 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49702 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49703 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49704 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49705 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49706 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49707 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49708 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49709 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49710 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49711 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49712 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49713 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49714 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49715 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49716 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49717 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49718 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49719 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49720 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49721 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49722 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49723 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49724 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49725 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49726 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49727 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49728 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49729 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49730 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49731 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49732 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49733 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49734 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49735 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49736 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49737 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49738 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49739 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49740 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49741 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49742 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49743 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49744 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49745 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49746 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49747 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49748 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49749 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49750 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49751 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49752 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49753 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49754 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49755 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49756 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49757 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49758 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49759 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49760 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49761 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49762 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49763 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49764 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49765 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49766 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49767 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49768 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49769 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49770 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49771 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49772 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49773 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49774 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49775 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49776 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49777 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49778 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49779 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49780 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49781 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49782 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49783 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49784 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49785 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49786 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49787 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49788 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49789 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49790 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49791 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49792 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49793 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49794 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49795 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49796 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49797 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49798 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49799 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49800 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49801 {
49802 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49803 }
49804 {
49805 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49806 }
49807 {
49808 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49809 }
49810 {
49811 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49812 }
49813 {
49814 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49815 }
49816 {
49817 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49818 }
49819 {
49820 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49821 }
49822 {
49823 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49824 }
49825 {
49826 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49827 }
49828 {
49829 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49830 }
49831 {
49832 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49833 }
49834 {
49835 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49836 }
49837 {
49838 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49839 }
49840 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49841 {
49842 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49843 }
49844 {
49845 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49846 }
49847 {
49848 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49849 }
49850 {
49851 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49852 }
49853 {
49854 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49855 }
49856 {
49857 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49858 }
49859 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49860 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49861 {
49862 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49863 }
49864 {
49865 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49866 }
49867 {
49868 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49869 }
49870 {
49871 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49875 }
49876 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49877 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49878 {
49879 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49880 }
49881 {
49882 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49883 }
49884 {
49885 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49886 }
49887 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49888 {
49889 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49890 }
49891 {
49892 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49893 }
49894 {
49895 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49896 }
49897 {
49898 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49899 }
49900 {
49901 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49902 }
49903 {
49904 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49905 }
49906 {
49907 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49908 }
49909 {
49910 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49911 }
49912 {
49913 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49914 }
49915 {
49916 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49917 }
49918 {
49919 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49920 }
49921 {
49922 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49923 }
49924 {
49925 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49926 }
49927 {
49928 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49929 }
49930 {
49931 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49932 }
49933 {
49934 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49935 }
49936 {
49937 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49938 }
49939 {
49940 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49941 }
49942 {
49943 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49944 }
49945
49946 // Initialize threading, some globals and such
49947 __wxPyPreStart(d);
49948
49949
49950 // Although these are defined in __version__ they need to be here too so
49951 // that an assert can be done to ensure that the wxPython and the wxWindows
49952 // versions match.
49953 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49954 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49955 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49956
49957 }
49958
wxWidgets (Impactor)