]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
use custom class which doesn't redraw everything on resize instead of SysTabCtl32...
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxMenuItem swig_types[56]
1398 #define SWIGTYPE_p_wxStaticBox swig_types[57]
1399 #define SWIGTYPE_p_long swig_types[58]
1400 #define SWIGTYPE_p_wxDuplexMode swig_types[59]
1401 #define SWIGTYPE_p_wxTIFFHandler swig_types[60]
1402 #define SWIGTYPE_p_wxXPMHandler swig_types[61]
1403 #define SWIGTYPE_p_wxPNMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxJPEGHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPCXHandler swig_types[64]
1406 #define SWIGTYPE_p_wxGIFHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPNGHandler swig_types[66]
1408 #define SWIGTYPE_p_wxANIHandler swig_types[67]
1409 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[68]
1410 #define SWIGTYPE_p_wxZipFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxInternetFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[71]
1413 #define SWIGTYPE_p_wxEvtHandler swig_types[72]
1414 #define SWIGTYPE_p_wxCURHandler swig_types[73]
1415 #define SWIGTYPE_p_wxICOHandler swig_types[74]
1416 #define SWIGTYPE_p_wxBMPHandler swig_types[75]
1417 #define SWIGTYPE_p_wxImageHandler swig_types[76]
1418 #define SWIGTYPE_p_wxFileSystemHandler swig_types[77]
1419 #define SWIGTYPE_p_wxRect swig_types[78]
1420 #define SWIGTYPE_p_wxButton swig_types[79]
1421 #define SWIGTYPE_p_wxGBSpan swig_types[80]
1422 #define SWIGTYPE_p_wxPropagateOnce swig_types[81]
1423 #define SWIGTYPE_p_wxAcceleratorTable swig_types[82]
1424 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[83]
1425 #define SWIGTYPE_p_char swig_types[84]
1426 #define SWIGTYPE_p_wxGBPosition swig_types[85]
1427 #define SWIGTYPE_p_wxImage swig_types[86]
1428 #define SWIGTYPE_p_wxFrame swig_types[87]
1429 #define SWIGTYPE_p_wxScrollWinEvent swig_types[88]
1430 #define SWIGTYPE_p_wxPaperSize swig_types[89]
1431 #define SWIGTYPE_p_wxImageHistogram swig_types[90]
1432 #define SWIGTYPE_p_wxPoint swig_types[91]
1433 #define SWIGTYPE_p_wxCursor swig_types[92]
1434 #define SWIGTYPE_p_wxObject swig_types[93]
1435 #define SWIGTYPE_p_wxInputStream swig_types[94]
1436 #define SWIGTYPE_p_wxOutputStream swig_types[95]
1437 #define SWIGTYPE_p_wxPyInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxDateTime swig_types[97]
1439 #define SWIGTYPE_p_wxKeyEvent swig_types[98]
1440 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[100]
1442 #define SWIGTYPE_p_unsigned_long swig_types[101]
1443 #define SWIGTYPE_p_wxWindow swig_types[102]
1444 #define SWIGTYPE_p_wxMenuBar swig_types[103]
1445 #define SWIGTYPE_p_wxFileSystem swig_types[104]
1446 #define SWIGTYPE_p_wxBitmap swig_types[105]
1447 #define SWIGTYPE_unsigned_int swig_types[106]
1448 #define SWIGTYPE_p_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_wxMenuEvent swig_types[108]
1450 #define SWIGTYPE_p_wxContextMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_unsigned_char swig_types[110]
1452 #define SWIGTYPE_p_wxEraseEvent swig_types[111]
1453 #define SWIGTYPE_p_wxMouseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxCloseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxPyApp swig_types[114]
1456 #define SWIGTYPE_p_wxCommandEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyDropTarget swig_types[117]
1459 #define SWIGTYPE_p_wxQuantize swig_types[118]
1460 #define SWIGTYPE_p_wxChildFocusEvent swig_types[119]
1461 #define SWIGTYPE_p_wxFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxDropFilesEvent swig_types[121]
1463 #define SWIGTYPE_p_wxControlWithItems swig_types[122]
1464 #define SWIGTYPE_p_wxColour swig_types[123]
1465 #define SWIGTYPE_p_wxValidator swig_types[124]
1466 #define SWIGTYPE_p_wxPyValidator swig_types[125]
1467 static swig_type_info *swig_types[127];
1468
1469 /* -------- TYPES TABLE (END) -------- */
1470
1471
1472 /*-----------------------------------------------
1473 @(target):= _core_.so
1474 ------------------------------------------------*/
1475 #define SWIG_init init_core_
1476
1477 #define SWIG_name "_core_"
1478
1479 #include "wx/wxPython/wxPython_int.h"
1480 #include "wx/wxPython/pyclasses.h"
1481
1482
1483 #ifndef wxPyUSE_EXPORT
1484 // Helper functions for dealing with SWIG objects and such. These are
1485 // located here so they know about the SWIG types and functions declared
1486 // in the wrapper code.
1487
1488 #include <wx/hashmap.h>
1489 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1490
1491
1492 // Maintains a hashmap of className to swig_type_info pointers. Given the
1493 // name of a class either looks up the type info in the cache, or scans the
1494 // SWIG tables for it.
1495 extern PyObject* wxPyPtrTypeMap;
1496 static
1497 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1498
1499 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1500
1501 if (typeInfoCache == NULL)
1502 typeInfoCache = new wxPyTypeInfoHashMap;
1503
1504 wxString name(className);
1505 swig_type_info* swigType = (*typeInfoCache)[name];
1506
1507 if (! swigType) {
1508 // it wasn't in the cache, so look it up from SWIG
1509 name.Append(wxT(" *"));
1510 swigType = SWIG_TypeQuery(name.mb_str());
1511
1512 // if it still wasn't found, try looking for a mapped name
1513 if (!swigType) {
1514 PyObject* item;
1515 name = className;
1516
1517 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1518 (char*)(const char*)name.mbc_str())) != NULL) {
1519 name = wxString(PyString_AsString(item), *wxConvCurrent);
1520 name.Append(wxT(" *"));
1521 swigType = SWIG_TypeQuery(name.mb_str());
1522 }
1523 }
1524 if (swigType) {
1525 // and add it to the map if found
1526 (*typeInfoCache)[className] = swigType;
1527 }
1528 }
1529 return swigType;
1530 }
1531
1532
1533 // Check if a class name is a type known to SWIG
1534 bool wxPyCheckSwigType(const wxChar* className) {
1535
1536 swig_type_info* swigType = wxPyFindSwigType(className);
1537 return swigType != NULL;
1538 }
1539
1540
1541 // Given a pointer to a C++ object and a class name, construct a Python proxy
1542 // object for it.
1543 PyObject* wxPyConstructObject(void* ptr,
1544 const wxChar* className,
1545 int setThisOwn) {
1546
1547 swig_type_info* swigType = wxPyFindSwigType(className);
1548 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1549
1550 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1551 }
1552
1553
1554 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1555 // Ensures that the proxy object is of the specified (or derived) type. If
1556 // not able to perform the conversion then a Python exception is set and the
1557 // error should be handled properly in the caller. Returns True on success.
1558 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1559 const wxChar* className) {
1560
1561 swig_type_info* swigType = wxPyFindSwigType(className);
1562 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1563
1564 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1565 }
1566
1567
1568 // Make a SWIGified pointer object suitable for a .this attribute
1569 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1570
1571 PyObject* robj = NULL;
1572
1573 swig_type_info* swigType = wxPyFindSwigType(className);
1574 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1575
1576 #ifdef SWIG_COBJECT_TYPES
1577 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1578 #else
1579 {
1580 char result[1024];
1581 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1582 PyString_FromString(result) : 0;
1583 }
1584 #endif
1585
1586 return robj;
1587 }
1588
1589
1590
1591
1592 // Export a C API in a struct. Other modules will be able to load this from
1593 // the wx._core_ module and will then have safe access to these functions,
1594 // even if they are located in another shared library.
1595 static wxPyCoreAPI API = {
1596
1597 wxPyCheckSwigType,
1598 wxPyConstructObject,
1599 wxPyConvertSwigPtr,
1600 wxPyMakeSwigPtr,
1601
1602 wxPyBeginAllowThreads,
1603 wxPyEndAllowThreads,
1604 wxPyBeginBlockThreads,
1605 wxPyEndBlockThreads,
1606
1607 wxPy_ConvertList,
1608
1609 wxString_in_helper,
1610 Py2wxString,
1611 wx2PyString,
1612
1613 byte_LIST_helper,
1614 int_LIST_helper,
1615 long_LIST_helper,
1616 string_LIST_helper,
1617 wxPoint_LIST_helper,
1618 wxBitmap_LIST_helper,
1619 wxString_LIST_helper,
1620 wxAcceleratorEntry_LIST_helper,
1621
1622 wxSize_helper,
1623 wxPoint_helper,
1624 wxRealPoint_helper,
1625 wxRect_helper,
1626 wxColour_helper,
1627 wxPoint2D_helper,
1628
1629 wxPySimple_typecheck,
1630 wxColour_typecheck,
1631
1632 wxPyCBH_setCallbackInfo,
1633 wxPyCBH_findCallback,
1634 wxPyCBH_callCallback,
1635 wxPyCBH_callCallbackObj,
1636 wxPyCBH_delete,
1637
1638 wxPyMake_wxObject,
1639 wxPyMake_wxSizer,
1640 wxPyPtrTypeMap_Add,
1641 wxPy2int_seq_helper,
1642 wxPy4int_seq_helper,
1643 wxArrayString2PyList_helper,
1644 wxArrayInt2PyList_helper,
1645
1646 wxPyClientData_dtor,
1647 wxPyUserData_dtor,
1648 wxPyOORClientData_dtor,
1649
1650 wxPyCBInputStream_create,
1651
1652 wxPyInstance_Check,
1653 wxPySwigInstance_Check,
1654
1655 wxPyCheckForApp
1656
1657 };
1658
1659 #endif
1660
1661
1662 #if !WXWIN_COMPATIBILITY_2_4
1663 #define wxHIDE_READONLY 0
1664 #endif
1665
1666
1667 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1668 #define SWIG_From_int PyInt_FromLong
1669 /*@@*/
1670
1671
1672 #if ! wxUSE_HOTKEY
1673 enum wxHotkeyModifier
1674 {
1675 wxMOD_NONE = 0,
1676 wxMOD_ALT = 1,
1677 wxMOD_CONTROL = 2,
1678 wxMOD_SHIFT = 4,
1679 wxMOD_WIN = 8
1680 };
1681 #define wxEVT_HOTKEY 9999
1682 #endif
1683
1684 static const wxString wxPyEmptyString(wxEmptyString);
1685 static wxString wxObject_GetClassName(wxObject *self){
1686 return self->GetClassInfo()->GetClassName();
1687 }
1688 static void wxObject_Destroy(wxObject *self){
1689 delete self;
1690 }
1691
1692 #ifndef __WXMAC__
1693 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1694 #endif
1695
1696
1697 #include <limits.h>
1698
1699
1700 SWIGINTERN int
1701 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1702 const char *errmsg)
1703 {
1704 if (value < min_value) {
1705 if (errmsg) {
1706 PyErr_Format(PyExc_OverflowError,
1707 "value %ld is less than '%s' minimum %ld",
1708 value, errmsg, min_value);
1709 }
1710 return 0;
1711 } else if (value > max_value) {
1712 if (errmsg) {
1713 PyErr_Format(PyExc_OverflowError,
1714 "value %ld is greater than '%s' maximum %ld",
1715 value, errmsg, max_value);
1716 }
1717 return 0;
1718 }
1719 return 1;
1720 }
1721
1722
1723 SWIGINTERN int
1724 SWIG_AsVal_long(PyObject* obj, long* val)
1725 {
1726 if (PyNumber_Check(obj)) {
1727 if (val) *val = PyInt_AsLong(obj);
1728 return 1;
1729 }
1730 else {
1731 SWIG_type_error("number", obj);
1732 }
1733 return 0;
1734 }
1735
1736
1737 #if INT_MAX != LONG_MAX
1738 SWIGINTERN int
1739 SWIG_AsVal_int(PyObject *obj, int *val)
1740 {
1741 const char* errmsg = val ? "int" : (char*)0;
1742 long v;
1743 if (SWIG_AsVal_long(obj, &v)) {
1744 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1745 if (val) *val = (int)(v);
1746 return 1;
1747 } else {
1748 return 0;
1749 }
1750 } else {
1751 PyErr_Clear();
1752 }
1753 if (val) {
1754 SWIG_type_error(errmsg, obj);
1755 }
1756 return 0;
1757 }
1758 #else
1759 SWIGINTERNSHORT int
1760 SWIG_AsVal_int(PyObject *obj, int *val)
1761 {
1762 return SWIG_AsVal_long(obj,(long*)val);
1763 }
1764 #endif
1765
1766
1767 SWIGINTERNSHORT int
1768 SWIG_As_int(PyObject* obj)
1769 {
1770 int v;
1771 if (!SWIG_AsVal_int(obj, &v)) {
1772 /*
1773 this is needed to make valgrind/purify happier.
1774 */
1775 memset((void*)&v, 0, sizeof(int));
1776 }
1777 return v;
1778 }
1779
1780
1781 SWIGINTERNSHORT int
1782 SWIG_Check_int(PyObject* obj)
1783 {
1784 return SWIG_AsVal_int(obj, (int*)0);
1785 }
1786
1787 static PyObject *wxSize_Get(wxSize *self){
1788 bool blocked = wxPyBeginBlockThreads();
1789 PyObject* tup = PyTuple_New(2);
1790 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1791 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1792 wxPyEndBlockThreads(blocked);
1793 return tup;
1794 }
1795
1796 SWIGINTERN int
1797 SWIG_AsVal_double(PyObject *obj, double* val)
1798 {
1799 if (PyNumber_Check(obj)) {
1800 if (val) *val = PyFloat_AsDouble(obj);
1801 return 1;
1802 }
1803 else {
1804 SWIG_type_error("number", obj);
1805 }
1806 return 0;
1807 }
1808
1809
1810 SWIGINTERNSHORT double
1811 SWIG_As_double(PyObject* obj)
1812 {
1813 double v;
1814 if (!SWIG_AsVal_double(obj, &v)) {
1815 /*
1816 this is needed to make valgrind/purify happier.
1817 */
1818 memset((void*)&v, 0, sizeof(double));
1819 }
1820 return v;
1821 }
1822
1823
1824 SWIGINTERNSHORT int
1825 SWIG_Check_double(PyObject* obj)
1826 {
1827 return SWIG_AsVal_double(obj, (double*)0);
1828 }
1829
1830
1831 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1832 #define SWIG_From_double PyFloat_FromDouble
1833 /*@@*/
1834
1835 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1836 self->x = x;
1837 self->y = y;
1838 }
1839 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1840 bool blocked = wxPyBeginBlockThreads();
1841 PyObject* tup = PyTuple_New(2);
1842 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1843 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1844 wxPyEndBlockThreads(blocked);
1845 return tup;
1846 }
1847
1848 SWIGINTERNSHORT long
1849 SWIG_As_long(PyObject* obj)
1850 {
1851 long v;
1852 if (!SWIG_AsVal_long(obj, &v)) {
1853 /*
1854 this is needed to make valgrind/purify happier.
1855 */
1856 memset((void*)&v, 0, sizeof(long));
1857 }
1858 return v;
1859 }
1860
1861
1862 SWIGINTERNSHORT int
1863 SWIG_Check_long(PyObject* obj)
1864 {
1865 return SWIG_AsVal_long(obj, (long*)0);
1866 }
1867
1868 static void wxPoint_Set(wxPoint *self,long x,long y){
1869 self->x = x;
1870 self->y = y;
1871 }
1872 static PyObject *wxPoint_Get(wxPoint *self){
1873 bool blocked = wxPyBeginBlockThreads();
1874 PyObject* tup = PyTuple_New(2);
1875 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1876 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1877 wxPyEndBlockThreads(blocked);
1878 return tup;
1879 }
1880 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1881 self->x = x;
1882 self->y = y;
1883 self->width = width;
1884 self->height = height;
1885 }
1886 static PyObject *wxRect_Get(wxRect *self){
1887 bool blocked = wxPyBeginBlockThreads();
1888 PyObject* tup = PyTuple_New(4);
1889 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1890 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1891 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1892 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1893 wxPyEndBlockThreads(blocked);
1894 return tup;
1895 }
1896
1897 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1898 wxRegion reg1(*r1);
1899 wxRegion reg2(*r2);
1900 wxRect dest(0,0,0,0);
1901 PyObject* obj;
1902
1903 reg1.Intersect(reg2);
1904 dest = reg1.GetBox();
1905
1906 if (dest != wxRect(0,0,0,0)) {
1907 bool blocked = wxPyBeginBlockThreads();
1908 wxRect* newRect = new wxRect(dest);
1909 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1910 wxPyEndBlockThreads(blocked);
1911 return obj;
1912 }
1913 Py_INCREF(Py_None);
1914 return Py_None;
1915 }
1916
1917
1918 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1919 PyObject* o2;
1920 PyObject* o3;
1921
1922 if (!target) {
1923 target = o;
1924 } else if (target == Py_None) {
1925 Py_DECREF(Py_None);
1926 target = o;
1927 } else {
1928 if (!PyTuple_Check(target)) {
1929 o2 = target;
1930 target = PyTuple_New(1);
1931 PyTuple_SetItem(target, 0, o2);
1932 }
1933 o3 = PyTuple_New(1);
1934 PyTuple_SetItem(o3, 0, o);
1935
1936 o2 = target;
1937 target = PySequence_Concat(o2, o3);
1938 Py_DECREF(o2);
1939 Py_DECREF(o3);
1940 }
1941 return target;
1942 }
1943
1944
1945 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1946 self->m_x = x;
1947 self->m_y = y;
1948 }
1949 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1950 bool blocked = wxPyBeginBlockThreads();
1951 PyObject* tup = PyTuple_New(2);
1952 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1953 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1954 wxPyEndBlockThreads(blocked);
1955 return tup;
1956 }
1957
1958 #include "wx/wxPython/pyistream.h"
1959
1960 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1961 wxInputStream* wxis = wxPyCBInputStream::create(p);
1962 if (wxis)
1963 return new wxPyInputStream(wxis);
1964 else
1965 return NULL;
1966 }
1967
1968 SWIGINTERNSHORT PyObject*
1969 SWIG_From_char(char c)
1970 {
1971 return PyString_FromStringAndSize(&c,1);
1972 }
1973
1974
1975 SWIGINTERNSHORT PyObject*
1976 SWIG_From_unsigned_SS_long(unsigned long value)
1977 {
1978 return (value > LONG_MAX) ?
1979 PyLong_FromUnsignedLong(value)
1980 : PyInt_FromLong((long)(value));
1981 }
1982
1983
1984 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1985 SWIGINTERN int
1986 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1987 {
1988 static swig_type_info* pchar_info = 0;
1989 char* vptr = 0;
1990 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1991 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1992 if (cptr) *cptr = vptr;
1993 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1994 return SWIG_OLDOBJ;
1995 } else {
1996 PyErr_Clear();
1997 if (PyString_Check(obj)) {
1998 if (cptr) {
1999 *cptr = PyString_AS_STRING(obj);
2000 if (psize) {
2001 *psize = PyString_GET_SIZE(obj) + 1;
2002 }
2003 }
2004 return SWIG_PYSTR;
2005 }
2006 }
2007 if (cptr) {
2008 SWIG_type_error("char *", obj);
2009 }
2010 return 0;
2011 }
2012
2013
2014 SWIGINTERN int
2015 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2016 {
2017 char* cptr; size_t csize;
2018 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2019 /* in C you can do:
2020
2021 char x[5] = "hello";
2022
2023 ie, assing the array using an extra '0' char.
2024 */
2025 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2026 if (csize <= size) {
2027 if (val) {
2028 if (csize) memcpy(val, cptr, csize);
2029 if (csize < size) memset(val + csize, 0, size - csize);
2030 }
2031 return 1;
2032 }
2033 }
2034 if (val) {
2035 PyErr_Format(PyExc_TypeError,
2036 "a char array of maximum size %lu is expected",
2037 (unsigned long) size);
2038 }
2039 return 0;
2040 }
2041
2042
2043 SWIGINTERN int
2044 SWIG_AsVal_char(PyObject *obj, char *val)
2045 {
2046 const char* errmsg = val ? "char" : (char*)0;
2047 long v;
2048 if (SWIG_AsVal_long(obj, &v)) {
2049 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2050 if (val) *val = (char)(v);
2051 return 1;
2052 } else {
2053 return 0;
2054 }
2055 } else {
2056 PyErr_Clear();
2057 return SWIG_AsCharArray(obj, val, 1);
2058 }
2059 }
2060
2061
2062 SWIGINTERNSHORT char
2063 SWIG_As_char(PyObject* obj)
2064 {
2065 char v;
2066 if (!SWIG_AsVal_char(obj, &v)) {
2067 /*
2068 this is needed to make valgrind/purify happier.
2069 */
2070 memset((void*)&v, 0, sizeof(char));
2071 }
2072 return v;
2073 }
2074
2075
2076 SWIGINTERNSHORT int
2077 SWIG_Check_char(PyObject* obj)
2078 {
2079 return SWIG_AsVal_char(obj, (char*)0);
2080 }
2081
2082
2083 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2084 #define SWIG_From_long PyInt_FromLong
2085 /*@@*/
2086
2087 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2088 // We use only strings for the streams, not unicode
2089 PyObject* str = PyObject_Str(obj);
2090 if (! str) {
2091 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2092 return;
2093 }
2094 self->Write(PyString_AS_STRING(str),
2095 PyString_GET_SIZE(str));
2096 Py_DECREF(str);
2097 }
2098
2099 #include "wx/wxPython/pyistream.h"
2100
2101
2102 class wxPyFileSystemHandler : public wxFileSystemHandler
2103 {
2104 public:
2105 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2106
2107 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2108 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2109 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2110 DEC_PYCALLBACK_STRING__pure(FindNext);
2111
2112 wxString GetProtocol(const wxString& location) {
2113 return wxFileSystemHandler::GetProtocol(location);
2114 }
2115
2116 wxString GetLeftLocation(const wxString& location) {
2117 return wxFileSystemHandler::GetLeftLocation(location);
2118 }
2119
2120 wxString GetAnchor(const wxString& location) {
2121 return wxFileSystemHandler::GetAnchor(location);
2122 }
2123
2124 wxString GetRightLocation(const wxString& location) {
2125 return wxFileSystemHandler::GetRightLocation(location);
2126 }
2127
2128 wxString GetMimeTypeFromExt(const wxString& location) {
2129 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2130 }
2131
2132 PYPRIVATE;
2133 };
2134
2135
2136 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2137 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2138 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2139 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2140
2141
2142 SWIGINTERN int
2143 SWIG_AsVal_bool(PyObject *obj, bool *val)
2144 {
2145 if (obj == Py_True) {
2146 if (val) *val = true;
2147 return 1;
2148 }
2149 if (obj == Py_False) {
2150 if (val) *val = false;
2151 return 1;
2152 }
2153 int res = 0;
2154 if (SWIG_AsVal_int(obj, &res)) {
2155 if (val) *val = res ? true : false;
2156 return 1;
2157 } else {
2158 PyErr_Clear();
2159 }
2160 if (val) {
2161 SWIG_type_error("bool", obj);
2162 }
2163 return 0;
2164 }
2165
2166
2167 SWIGINTERNSHORT bool
2168 SWIG_As_bool(PyObject* obj)
2169 {
2170 bool v;
2171 if (!SWIG_AsVal_bool(obj, &v)) {
2172 /*
2173 this is needed to make valgrind/purify happier.
2174 */
2175 memset((void*)&v, 0, sizeof(bool));
2176 }
2177 return v;
2178 }
2179
2180
2181 SWIGINTERNSHORT int
2182 SWIG_Check_bool(PyObject* obj)
2183 {
2184 return SWIG_AsVal_bool(obj, (bool*)0);
2185 }
2186
2187 static wxString FileSystem_URLToFileName(wxString const &url){
2188 wxFileName fname = wxFileSystem::URLToFileName(url);
2189 return fname.GetFullPath();
2190 }
2191
2192 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2193 wxImage& image,
2194 long type) {
2195 wxMemoryFSHandler::AddFile(filename, image, type);
2196 }
2197
2198 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2199 const wxBitmap& bitmap,
2200 long type) {
2201 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2202 }
2203
2204 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2205 PyObject* data) {
2206 if (! PyString_Check(data)) {
2207 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2208 "Expected string object"));
2209 return;
2210 }
2211
2212 bool blocked = wxPyBeginBlockThreads();
2213 void* ptr = (void*)PyString_AsString(data);
2214 size_t size = PyString_Size(data);
2215 wxPyEndBlockThreads(blocked);
2216
2217 wxMemoryFSHandler::AddFile(filename, ptr, size);
2218 }
2219
2220
2221 #include "wx/wxPython/pyistream.h"
2222
2223
2224 SWIGINTERN int
2225 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2226 {
2227 long v = 0;
2228 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2229 SWIG_type_error("unsigned number", obj);
2230 }
2231 else if (val)
2232 *val = (unsigned long)v;
2233 return 1;
2234 }
2235
2236
2237 SWIGINTERNSHORT int
2238 SWIG_CheckUnsignedLongInRange(unsigned long value,
2239 unsigned long max_value,
2240 const char *errmsg)
2241 {
2242 if (value > max_value) {
2243 if (errmsg) {
2244 PyErr_Format(PyExc_OverflowError,
2245 "value %lu is greater than '%s' minimum %lu",
2246 value, errmsg, max_value);
2247 }
2248 return 0;
2249 }
2250 return 1;
2251 }
2252
2253
2254 SWIGINTERN int
2255 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2256 {
2257 const char* errmsg = val ? "unsigned char" : (char*)0;
2258 unsigned long v;
2259 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2260 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2261 if (val) *val = (unsigned char)(v);
2262 return 1;
2263 } else {
2264 return 0;
2265 }
2266 } else {
2267 PyErr_Clear();
2268 }
2269 if (val) {
2270 SWIG_type_error(errmsg, obj);
2271 }
2272 return 0;
2273 }
2274
2275
2276 SWIGINTERNSHORT unsigned char
2277 SWIG_As_unsigned_SS_char(PyObject* obj)
2278 {
2279 unsigned char v;
2280 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2281 /*
2282 this is needed to make valgrind/purify happier.
2283 */
2284 memset((void*)&v, 0, sizeof(unsigned char));
2285 }
2286 return v;
2287 }
2288
2289
2290 SWIGINTERNSHORT int
2291 SWIG_Check_unsigned_SS_char(PyObject* obj)
2292 {
2293 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2294 }
2295
2296
2297 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2298 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2299 /*@@*/
2300
2301
2302 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2303 if (width > 0 && height > 0)
2304 return new wxImage(width, height, clear);
2305 else
2306 return new wxImage;
2307 }
2308 static wxImage *new_wxImage(wxBitmap const &bitmap){
2309 return new wxImage(bitmap.ConvertToImage());
2310 }
2311 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2312 // Copy the source data so the wxImage can clean it up later
2313 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2314 if (copy == NULL) {
2315 PyErr_NoMemory();
2316 return NULL;
2317 }
2318 memcpy(copy, data, width*height*3);
2319 return new wxImage(width, height, copy, false);
2320 }
2321 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2322 // Copy the source data so the wxImage can clean it up later
2323 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2324 if (dcopy == NULL) {
2325 PyErr_NoMemory();
2326 return NULL;
2327 }
2328 memcpy(dcopy, data, width*height*3);
2329 unsigned char* acopy = (unsigned char*)malloc(width*height);
2330 if (acopy == NULL) {
2331 PyErr_NoMemory();
2332 return NULL;
2333 }
2334 memcpy(acopy, alpha, width*height);
2335
2336 return new wxImage(width, height, dcopy, acopy, false);
2337 }
2338 static wxSize wxImage_GetSize(wxImage *self){
2339 wxSize size(self->GetWidth(), self->GetHeight());
2340 return size;
2341 }
2342 static PyObject *wxImage_GetData(wxImage *self){
2343 unsigned char* data = self->GetData();
2344 int len = self->GetWidth() * self->GetHeight() * 3;
2345 PyObject* rv;
2346 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2347 return rv;
2348 }
2349 static void wxImage_SetData(wxImage *self,PyObject *data){
2350 unsigned char* dataPtr;
2351
2352 if (! PyString_Check(data)) {
2353 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2354 "Expected string object"));
2355 return /* NULL */ ;
2356 }
2357
2358 size_t len = self->GetWidth() * self->GetHeight() * 3;
2359 dataPtr = (unsigned char*) malloc(len);
2360 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2361 self->SetData(dataPtr);
2362 // wxImage takes ownership of dataPtr...
2363 }
2364 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2365 unsigned char* data = self->GetData();
2366 int len = self->GetWidth() * self->GetHeight() * 3;
2367 PyObject* rv;
2368 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2369 return rv;
2370 }
2371 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2372 unsigned char* buffer;
2373 int size;
2374
2375 bool blocked = wxPyBeginBlockThreads();
2376 if (!PyArg_Parse(data, "t#", &buffer, &size))
2377 goto done;
2378
2379 if (size != self->GetWidth() * self->GetHeight() * 3) {
2380 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2381 goto done;
2382 }
2383 self->SetData(buffer);
2384 done:
2385 wxPyEndBlockThreads(blocked);
2386 }
2387 static PyObject *wxImage_GetAlphaData(wxImage *self){
2388 unsigned char* data = self->GetAlpha();
2389 if (! data) {
2390 RETURN_NONE();
2391 } else {
2392 int len = self->GetWidth() * self->GetHeight();
2393 PyObject* rv;
2394 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2395 return rv;
2396 }
2397 }
2398 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2399 unsigned char* dataPtr;
2400
2401 if (! PyString_Check(data)) {
2402 PyErr_SetString(PyExc_TypeError, "Expected string object");
2403 return /* NULL */ ;
2404 }
2405
2406 size_t len = self->GetWidth() * self->GetHeight();
2407 dataPtr = (unsigned char*) malloc(len);
2408 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2409 self->SetAlpha(dataPtr);
2410 // wxImage takes ownership of dataPtr...
2411 }
2412 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2413 unsigned char* data = self->GetAlpha();
2414 int len = self->GetWidth() * self->GetHeight();
2415 PyObject* rv;
2416 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2417 return rv;
2418 }
2419 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2420 unsigned char* buffer;
2421 int size;
2422
2423 bool blocked = wxPyBeginBlockThreads();
2424 if (!PyArg_Parse(data, "t#", &buffer, &size))
2425 goto done;
2426
2427 if (size != self->GetWidth() * self->GetHeight()) {
2428 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2429 goto done;
2430 }
2431 self->SetAlpha(buffer);
2432 done:
2433 wxPyEndBlockThreads(blocked);
2434 }
2435
2436 SWIGINTERNSHORT unsigned long
2437 SWIG_As_unsigned_SS_long(PyObject* obj)
2438 {
2439 unsigned long v;
2440 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2441 /*
2442 this is needed to make valgrind/purify happier.
2443 */
2444 memset((void*)&v, 0, sizeof(unsigned long));
2445 }
2446 return v;
2447 }
2448
2449
2450 SWIGINTERNSHORT int
2451 SWIG_Check_unsigned_SS_long(PyObject* obj)
2452 {
2453 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2454 }
2455
2456 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2457 wxBitmap bitmap(*self, depth);
2458 return bitmap;
2459 }
2460 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2461 wxImage mono = self->ConvertToMono( red, green, blue );
2462 wxBitmap bitmap( mono, 1 );
2463 return bitmap;
2464 }
2465 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2466 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2467 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2468 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2469 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2470
2471 #include <wx/quantize.h>
2472
2473 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2474 return wxQuantize::Quantize(src, dest,
2475 //NULL, // palette
2476 desiredNoColours,
2477 NULL, // eightBitData
2478 flags);
2479 }
2480 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2481 if (PyCallable_Check(func)) {
2482 self->Connect(id, lastId, eventType,
2483 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2484 new wxPyCallback(func));
2485 }
2486 else if (func == Py_None) {
2487 self->Disconnect(id, lastId, eventType,
2488 (wxObjectEventFunction)
2489 &wxPyCallback::EventThunker);
2490 }
2491 else {
2492 wxPyBLOCK_THREADS(
2493 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2494 }
2495 }
2496 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2497 return self->Disconnect(id, lastId, eventType,
2498 (wxObjectEventFunction)
2499 &wxPyCallback::EventThunker);
2500 }
2501 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2502 if (_self && _self != Py_None) {
2503 self->SetClientObject(new wxPyOORClientData(_self, incref));
2504 }
2505 else {
2506 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2507 if (data) {
2508 self->SetClientObject(NULL); // This will delete it too
2509 }
2510 }
2511 }
2512
2513 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2514 #if wxUSE_UNICODE
2515 return self->GetUnicodeKey();
2516 #else
2517 return 0;
2518 #endif
2519 }
2520
2521 #if UINT_MAX < LONG_MAX
2522 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2523 #define SWIG_From_unsigned_SS_int SWIG_From_long
2524 /*@@*/
2525 #else
2526 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2527 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2528 /*@@*/
2529 #endif
2530
2531
2532 #if UINT_MAX != ULONG_MAX
2533 SWIGINTERN int
2534 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2535 {
2536 const char* errmsg = val ? "unsigned int" : (char*)0;
2537 unsigned long v;
2538 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2539 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2540 if (val) *val = (unsigned int)(v);
2541 return 1;
2542 }
2543 } else {
2544 PyErr_Clear();
2545 }
2546 if (val) {
2547 SWIG_type_error(errmsg, obj);
2548 }
2549 return 0;
2550 }
2551 #else
2552 SWIGINTERNSHORT unsigned int
2553 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2554 {
2555 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2556 }
2557 #endif
2558
2559
2560 SWIGINTERNSHORT unsigned int
2561 SWIG_As_unsigned_SS_int(PyObject* obj)
2562 {
2563 unsigned int v;
2564 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2565 /*
2566 this is needed to make valgrind/purify happier.
2567 */
2568 memset((void*)&v, 0, sizeof(unsigned int));
2569 }
2570 return v;
2571 }
2572
2573
2574 SWIGINTERNSHORT int
2575 SWIG_Check_unsigned_SS_int(PyObject* obj)
2576 {
2577 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2578 }
2579
2580 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2581 self->m_size = size;
2582 }
2583 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2584 int count = self->GetNumberOfFiles();
2585 wxString* files = self->GetFiles();
2586 PyObject* list = PyList_New(count);
2587
2588 if (!list) {
2589 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2590 return NULL;
2591 }
2592
2593 for (int i=0; i<count; i++) {
2594 PyList_SetItem(list, i, wx2PyString(files[i]));
2595 }
2596 return list;
2597 }
2598
2599
2600 static wxPyApp *new_wxPyApp(){
2601 wxPythonApp = new wxPyApp();
2602 return wxPythonApp;
2603 }
2604 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2605
2606 void wxApp_CleanUp() {
2607 __wxPyCleanup();
2608 }
2609
2610
2611 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2612
2613
2614 SWIGINTERNSHORT int
2615 SWIG_AsCharPtr(PyObject *obj, char **val)
2616 {
2617 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2618 return 1;
2619 }
2620 if (val) {
2621 PyErr_Clear();
2622 SWIG_type_error("char *", obj);
2623 }
2624 return 0;
2625 }
2626
2627
2628 SWIGINTERN PyObject *
2629 SWIG_FromCharPtr(const char* cptr)
2630 {
2631 if (cptr) {
2632 size_t size = strlen(cptr);
2633 if (size > INT_MAX) {
2634 return SWIG_NewPointerObj((char*)(cptr),
2635 SWIG_TypeQuery("char *"), 0);
2636 } else {
2637 if (size != 0) {
2638 return PyString_FromStringAndSize(cptr, size);
2639 } else {
2640 return PyString_FromString(cptr);
2641 }
2642 }
2643 }
2644 Py_INCREF(Py_None);
2645 return Py_None;
2646 }
2647
2648
2649 #ifdef __WXMAC__
2650
2651 // A dummy class that raises an exception if used...
2652 class wxEventLoop
2653 {
2654 public:
2655 wxEventLoop() { wxPyRaiseNotImplemented(); }
2656 int Run() { return 0; }
2657 void Exit(int rc = 0) {}
2658 bool Pending() const { return false; }
2659 bool Dispatch() { return false; }
2660 bool IsRunning() const { return false; }
2661 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2662 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2663 };
2664
2665 #else
2666
2667 #include <wx/evtloop.h>
2668
2669 #endif
2670
2671
2672
2673 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2674 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2675 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2676 static PyObject *wxWindow_GetChildren(wxWindow *self){
2677 wxWindowList& list = self->GetChildren();
2678 return wxPy_ConvertList(&list);
2679 }
2680 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2681 #if wxUSE_HOTKEY
2682 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2683 #else
2684 return false;
2685 #endif
2686 }
2687 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2688
2689
2690
2691 return false;
2692
2693 }
2694 static long wxWindow_GetHandle(wxWindow *self){
2695 return wxPyGetWinHandle(self);
2696 }
2697 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2698 self->AssociateHandle((WXWidget)handle);
2699 }
2700
2701 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2702 return wxWindow::FindWindowById(id, parent);
2703 }
2704
2705 wxWindow* wxFindWindowByName( const wxString& name,
2706 const wxWindow *parent = NULL ) {
2707 return wxWindow::FindWindowByName(name, parent);
2708 }
2709
2710 wxWindow* wxFindWindowByLabel( const wxString& label,
2711 const wxWindow *parent = NULL ) {
2712 return wxWindow::FindWindowByLabel(label, parent);
2713 }
2714
2715
2716 #ifdef __WXMSW__
2717 #include <wx/msw/private.h> // to get wxGetWindowId
2718 #endif
2719
2720
2721 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2722 #ifdef __WXMSW__
2723 WXHWND hWnd = (WXHWND)_hWnd;
2724 long id = wxGetWindowId(hWnd);
2725 wxWindow* win = new wxWindow;
2726 parent->AddChild(win);
2727 win->SetEventHandler(win);
2728 win->SetHWND(hWnd);
2729 win->SetId(id);
2730 win->SubclassWin(hWnd);
2731 win->AdoptAttributesFromHWND();
2732 win->SetupColours();
2733 return win;
2734 #else
2735 wxPyRaiseNotImplemented();
2736 return NULL;
2737 #endif
2738 }
2739
2740
2741 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2742 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2743 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2744
2745 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2746
2747 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2748 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2749 wxMenuItemList& list = self->GetMenuItems();
2750 return wxPy_ConvertList(&list);
2751 }
2752 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2753 static const wxString wxPyControlNameStr(wxControlNameStr);
2754 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2755 if (clientData) {
2756 wxPyClientData* data = new wxPyClientData(clientData);
2757 return self->Append(item, data);
2758 } else
2759 return self->Append(item);
2760 }
2761 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2762 if (clientData) {
2763 wxPyClientData* data = new wxPyClientData(clientData);
2764 return self->Insert(item, pos, data);
2765 } else
2766 return self->Insert(item, pos);
2767 }
2768 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2769 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2770 if (data) {
2771 Py_INCREF(data->m_obj);
2772 return data->m_obj;
2773 } else {
2774 Py_INCREF(Py_None);
2775 return Py_None;
2776 }
2777 }
2778 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2779 wxPyClientData* data = new wxPyClientData(clientData);
2780 self->SetClientObject(n, data);
2781 }
2782
2783
2784 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2785 wxPyUserData* data = NULL;
2786 if ( userData ) {
2787 bool blocked = wxPyBeginBlockThreads();
2788 data = new wxPyUserData(userData);
2789 wxPyEndBlockThreads(blocked);
2790 }
2791 return new wxSizerItem(window, proportion, flag, border, data);
2792 }
2793 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2794 wxPyUserData* data = NULL;
2795 if ( userData ) {
2796 bool blocked = wxPyBeginBlockThreads();
2797 data = new wxPyUserData(userData);
2798 wxPyEndBlockThreads(blocked);
2799 }
2800 return new wxSizerItem(width, height, proportion, flag, border, data);
2801 }
2802 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2803 wxPyUserData* data = NULL;
2804 if ( userData ) {
2805 bool blocked = wxPyBeginBlockThreads();
2806 data = new wxPyUserData(userData);
2807 wxPyEndBlockThreads(blocked);
2808 }
2809 return new wxSizerItem(sizer, proportion, flag, border, data);
2810 }
2811
2812 #include <float.h>
2813 SWIGINTERN int
2814 SWIG_CheckDoubleInRange(double value, double min_value,
2815 double max_value, const char* errmsg)
2816 {
2817 if (value < min_value) {
2818 if (errmsg) {
2819 PyErr_Format(PyExc_OverflowError,
2820 "value %g is less than %s minimum %g",
2821 value, errmsg, min_value);
2822 }
2823 return 0;
2824 } else if (value > max_value) {
2825 if (errmsg) {
2826 PyErr_Format(PyExc_OverflowError,
2827 "value %g is greater than %s maximum %g",
2828 value, errmsg, max_value);
2829 }
2830 return 0;
2831 }
2832 return 1;
2833 }
2834
2835
2836 SWIGINTERN int
2837 SWIG_AsVal_float(PyObject *obj, float *val)
2838 {
2839 const char* errmsg = val ? "float" : (char*)0;
2840 double v;
2841 if (SWIG_AsVal_double(obj, &v)) {
2842 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2843 if (val) *val = (float)(v);
2844 return 1;
2845 } else {
2846 return 0;
2847 }
2848 } else {
2849 PyErr_Clear();
2850 }
2851 if (val) {
2852 SWIG_type_error(errmsg, obj);
2853 }
2854 return 0;
2855 }
2856
2857
2858 SWIGINTERNSHORT float
2859 SWIG_As_float(PyObject* obj)
2860 {
2861 float v;
2862 if (!SWIG_AsVal_float(obj, &v)) {
2863 /*
2864 this is needed to make valgrind/purify happier.
2865 */
2866 memset((void*)&v, 0, sizeof(float));
2867 }
2868 return v;
2869 }
2870
2871
2872 SWIGINTERNSHORT int
2873 SWIG_Check_float(PyObject* obj)
2874 {
2875 return SWIG_AsVal_float(obj, (float*)0);
2876 }
2877
2878
2879 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2880 #define SWIG_From_float PyFloat_FromDouble
2881 /*@@*/
2882
2883 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2884 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2885 if (data) {
2886 Py_INCREF(data->m_obj);
2887 return data->m_obj;
2888 } else {
2889 Py_INCREF(Py_None);
2890 return Py_None;
2891 }
2892 }
2893
2894 // Figure out the type of the sizer item
2895
2896 struct wxPySizerItemInfo {
2897 wxPySizerItemInfo()
2898 : window(NULL), sizer(NULL), gotSize(false),
2899 size(wxDefaultSize), gotPos(false), pos(-1)
2900 {}
2901
2902 wxWindow* window;
2903 wxSizer* sizer;
2904 bool gotSize;
2905 wxSize size;
2906 bool gotPos;
2907 int pos;
2908 };
2909
2910 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2911
2912 wxPySizerItemInfo info;
2913 wxSize size;
2914 wxSize* sizePtr = &size;
2915
2916 // Find out what the type of the item is
2917 // try wxWindow
2918 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2919 PyErr_Clear();
2920 info.window = NULL;
2921
2922 // try wxSizer
2923 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2924 PyErr_Clear();
2925 info.sizer = NULL;
2926
2927 // try wxSize or (w,h)
2928 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2929 info.size = *sizePtr;
2930 info.gotSize = true;
2931 }
2932
2933 // or a single int
2934 if (checkIdx && PyInt_Check(item)) {
2935 info.pos = PyInt_AsLong(item);
2936 info.gotPos = true;
2937 }
2938 }
2939 }
2940
2941 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2942 // no expected type, figure out what kind of error message to generate
2943 if ( !checkSize && !checkIdx )
2944 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2945 else if ( checkSize && !checkIdx )
2946 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2947 else if ( !checkSize && checkIdx)
2948 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2949 else
2950 // can this one happen?
2951 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2952 }
2953
2954 return info;
2955 }
2956
2957 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2958 if (!self->GetClientObject())
2959 self->SetClientObject(new wxPyOORClientData(_self));
2960 }
2961 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2962
2963 wxPyUserData* data = NULL;
2964 bool blocked = wxPyBeginBlockThreads();
2965 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2966 if ( userData && (info.window || info.sizer || info.gotSize) )
2967 data = new wxPyUserData(userData);
2968 wxPyEndBlockThreads(blocked);
2969
2970 // Now call the real Add method if a valid item type was found
2971 if ( info.window )
2972 return self->Add(info.window, proportion, flag, border, data);
2973 else if ( info.sizer )
2974 return self->Add(info.sizer, proportion, flag, border, data);
2975 else if (info.gotSize)
2976 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2977 proportion, flag, border, data);
2978 else
2979 return NULL;
2980 }
2981 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2982
2983 wxPyUserData* data = NULL;
2984 bool blocked = wxPyBeginBlockThreads();
2985 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2986 if ( userData && (info.window || info.sizer || info.gotSize) )
2987 data = new wxPyUserData(userData);
2988 wxPyEndBlockThreads(blocked);
2989
2990 // Now call the real Insert method if a valid item type was found
2991 if ( info.window )
2992 return self->Insert(before, info.window, proportion, flag, border, data);
2993 else if ( info.sizer )
2994 return self->Insert(before, info.sizer, proportion, flag, border, data);
2995 else if (info.gotSize)
2996 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
2997 proportion, flag, border, data);
2998 else
2999 return NULL;
3000 }
3001 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3002
3003 wxPyUserData* data = NULL;
3004 bool blocked = wxPyBeginBlockThreads();
3005 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3006 if ( userData && (info.window || info.sizer || info.gotSize) )
3007 data = new wxPyUserData(userData);
3008 wxPyEndBlockThreads(blocked);
3009
3010 // Now call the real Prepend method if a valid item type was found
3011 if ( info.window )
3012 return self->Prepend(info.window, proportion, flag, border, data);
3013 else if ( info.sizer )
3014 return self->Prepend(info.sizer, proportion, flag, border, data);
3015 else if (info.gotSize)
3016 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3017 proportion, flag, border, data);
3018 else
3019 return NULL;
3020 }
3021 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3022 bool blocked = wxPyBeginBlockThreads();
3023 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3024 wxPyEndBlockThreads(blocked);
3025 if ( info.window )
3026 return self->Remove(info.window);
3027 else if ( info.sizer )
3028 return self->Remove(info.sizer);
3029 else if ( info.gotPos )
3030 return self->Remove(info.pos);
3031 else
3032 return false;
3033 }
3034 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3035 bool blocked = wxPyBeginBlockThreads();
3036 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3037 wxPyEndBlockThreads(blocked);
3038 if ( info.window )
3039 return self->Detach(info.window);
3040 else if ( info.sizer )
3041 return self->Detach(info.sizer);
3042 else if ( info.gotPos )
3043 return self->Detach(info.pos);
3044 else
3045 return false;
3046 }
3047 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3048 bool blocked = wxPyBeginBlockThreads();
3049 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3050 wxPyEndBlockThreads(blocked);
3051 if ( info.window )
3052 return self->GetItem(info.window);
3053 else if ( info.sizer )
3054 return self->GetItem(info.sizer);
3055 else if ( info.gotPos )
3056 return self->GetItem(info.pos);
3057 else
3058 return NULL;
3059 }
3060 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3061 bool blocked = wxPyBeginBlockThreads();
3062 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3063 wxPyEndBlockThreads(blocked);
3064 if ( info.window )
3065 self->SetItemMinSize(info.window, size);
3066 else if ( info.sizer )
3067 self->SetItemMinSize(info.sizer, size);
3068 else if ( info.gotPos )
3069 self->SetItemMinSize(info.pos, size);
3070 }
3071 static PyObject *wxSizer_GetChildren(wxSizer *self){
3072 wxSizerItemList& list = self->GetChildren();
3073 return wxPy_ConvertList(&list);
3074 }
3075 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3076 bool blocked = wxPyBeginBlockThreads();
3077 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3078 wxPyEndBlockThreads(blocked);
3079 if ( info.window )
3080 return self->Show(info.window, show, recursive);
3081 else if ( info.sizer )
3082 return self->Show(info.sizer, show, recursive);
3083 else if ( info.gotPos )
3084 return self->Show(info.pos, show);
3085 else
3086 return false;
3087 }
3088 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3089 bool blocked = wxPyBeginBlockThreads();
3090 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3091 wxPyEndBlockThreads(blocked);
3092 if ( info.window )
3093 return self->IsShown(info.window);
3094 else if ( info.sizer )
3095 return self->IsShown(info.sizer);
3096 else if ( info.gotPos )
3097 return self->IsShown(info.pos);
3098 else
3099 return false;
3100 }
3101
3102 // See pyclasses.h
3103 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3104 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3105 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3106
3107
3108
3109
3110 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3111 {
3112 if (source == Py_None) {
3113 **obj = wxGBPosition(-1,-1);
3114 return true;
3115 }
3116 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3117 }
3118
3119 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3120 {
3121 if (source == Py_None) {
3122 **obj = wxGBSpan(-1,-1);
3123 return true;
3124 }
3125 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3126 }
3127
3128
3129 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3130 self->SetRow(row);
3131 self->SetCol(col);
3132 }
3133 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3134 bool blocked = wxPyBeginBlockThreads();
3135 PyObject* tup = PyTuple_New(2);
3136 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3137 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3138 wxPyEndBlockThreads(blocked);
3139 return tup;
3140 }
3141 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3142 self->SetRowspan(rowspan);
3143 self->SetColspan(colspan);
3144 }
3145 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3146 bool blocked = wxPyBeginBlockThreads();
3147 PyObject* tup = PyTuple_New(2);
3148 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3149 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3150 wxPyEndBlockThreads(blocked);
3151 return tup;
3152 }
3153 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3154 wxPyUserData* data = NULL;
3155 if ( userData ) {
3156 bool blocked = wxPyBeginBlockThreads();
3157 data = new wxPyUserData(userData);
3158 wxPyEndBlockThreads(blocked);
3159 }
3160 return new wxGBSizerItem(window, pos, span, flag, border, data);
3161 }
3162 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3163 wxPyUserData* data = NULL;
3164 if ( userData ) {
3165 bool blocked = wxPyBeginBlockThreads();
3166 data = new wxPyUserData(userData);
3167 wxPyEndBlockThreads(blocked);
3168 }
3169 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3170 }
3171 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3172 wxPyUserData* data = NULL;
3173 if ( userData ) {
3174 bool blocked = wxPyBeginBlockThreads();
3175 data = new wxPyUserData(userData);
3176 wxPyEndBlockThreads(blocked);
3177 }
3178 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3179 }
3180 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3181 int row, col;
3182 self->GetEndPos(row, col);
3183 return wxGBPosition(row, col);
3184 }
3185 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3186
3187 wxPyUserData* data = NULL;
3188 bool blocked = wxPyBeginBlockThreads();
3189 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3190 if ( userData && (info.window || info.sizer || info.gotSize) )
3191 data = new wxPyUserData(userData);
3192 wxPyEndBlockThreads(blocked);
3193
3194 // Now call the real Add method if a valid item type was found
3195 if ( info.window )
3196 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3197 else if ( info.sizer )
3198 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3199 else if (info.gotSize)
3200 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3201 pos, span, flag, border, data);
3202 return NULL;
3203 }
3204
3205
3206 #ifdef __cplusplus
3207 extern "C" {
3208 #endif
3209 static int _wrap_EmptyString_set(PyObject *) {
3210 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3211 return 1;
3212 }
3213
3214
3215 static PyObject *_wrap_EmptyString_get(void) {
3216 PyObject *pyobj;
3217
3218 {
3219 #if wxUSE_UNICODE
3220 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3221 #else
3222 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3223 #endif
3224 }
3225 return pyobj;
3226 }
3227
3228
3229 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3230 PyObject *resultobj;
3231 wxObject *arg1 = (wxObject *) 0 ;
3232 wxString result;
3233 PyObject * obj0 = 0 ;
3234 char *kwnames[] = {
3235 (char *) "self", NULL
3236 };
3237
3238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3240 if (SWIG_arg_fail(1)) SWIG_fail;
3241 {
3242 PyThreadState* __tstate = wxPyBeginAllowThreads();
3243 result = wxObject_GetClassName(arg1);
3244
3245 wxPyEndAllowThreads(__tstate);
3246 if (PyErr_Occurred()) SWIG_fail;
3247 }
3248 {
3249 #if wxUSE_UNICODE
3250 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3251 #else
3252 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3253 #endif
3254 }
3255 return resultobj;
3256 fail:
3257 return NULL;
3258 }
3259
3260
3261 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3262 PyObject *resultobj;
3263 wxObject *arg1 = (wxObject *) 0 ;
3264 PyObject * obj0 = 0 ;
3265 char *kwnames[] = {
3266 (char *) "self", NULL
3267 };
3268
3269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3271 if (SWIG_arg_fail(1)) SWIG_fail;
3272 {
3273 PyThreadState* __tstate = wxPyBeginAllowThreads();
3274 wxObject_Destroy(arg1);
3275
3276 wxPyEndAllowThreads(__tstate);
3277 if (PyErr_Occurred()) SWIG_fail;
3278 }
3279 Py_INCREF(Py_None); resultobj = Py_None;
3280 return resultobj;
3281 fail:
3282 return NULL;
3283 }
3284
3285
3286 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3287 PyObject *obj;
3288 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3289 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3290 Py_INCREF(obj);
3291 return Py_BuildValue((char *)"");
3292 }
3293 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3294 PyObject *resultobj;
3295 wxSize *arg1 = (wxSize *) 0 ;
3296 int arg2 ;
3297 PyObject * obj0 = 0 ;
3298 PyObject * obj1 = 0 ;
3299 char *kwnames[] = {
3300 (char *) "self",(char *) "x", NULL
3301 };
3302
3303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3305 if (SWIG_arg_fail(1)) SWIG_fail;
3306 {
3307 arg2 = (int)(SWIG_As_int(obj1));
3308 if (SWIG_arg_fail(2)) SWIG_fail;
3309 }
3310 if (arg1) (arg1)->x = arg2;
3311
3312 Py_INCREF(Py_None); resultobj = Py_None;
3313 return resultobj;
3314 fail:
3315 return NULL;
3316 }
3317
3318
3319 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3320 PyObject *resultobj;
3321 wxSize *arg1 = (wxSize *) 0 ;
3322 int result;
3323 PyObject * obj0 = 0 ;
3324 char *kwnames[] = {
3325 (char *) "self", NULL
3326 };
3327
3328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3330 if (SWIG_arg_fail(1)) SWIG_fail;
3331 result = (int) ((arg1)->x);
3332
3333 {
3334 resultobj = SWIG_From_int((int)(result));
3335 }
3336 return resultobj;
3337 fail:
3338 return NULL;
3339 }
3340
3341
3342 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3343 PyObject *resultobj;
3344 wxSize *arg1 = (wxSize *) 0 ;
3345 int arg2 ;
3346 PyObject * obj0 = 0 ;
3347 PyObject * obj1 = 0 ;
3348 char *kwnames[] = {
3349 (char *) "self",(char *) "y", NULL
3350 };
3351
3352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3354 if (SWIG_arg_fail(1)) SWIG_fail;
3355 {
3356 arg2 = (int)(SWIG_As_int(obj1));
3357 if (SWIG_arg_fail(2)) SWIG_fail;
3358 }
3359 if (arg1) (arg1)->y = arg2;
3360
3361 Py_INCREF(Py_None); resultobj = Py_None;
3362 return resultobj;
3363 fail:
3364 return NULL;
3365 }
3366
3367
3368 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3369 PyObject *resultobj;
3370 wxSize *arg1 = (wxSize *) 0 ;
3371 int result;
3372 PyObject * obj0 = 0 ;
3373 char *kwnames[] = {
3374 (char *) "self", NULL
3375 };
3376
3377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3379 if (SWIG_arg_fail(1)) SWIG_fail;
3380 result = (int) ((arg1)->y);
3381
3382 {
3383 resultobj = SWIG_From_int((int)(result));
3384 }
3385 return resultobj;
3386 fail:
3387 return NULL;
3388 }
3389
3390
3391 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3392 PyObject *resultobj;
3393 int arg1 = (int) 0 ;
3394 int arg2 = (int) 0 ;
3395 wxSize *result;
3396 PyObject * obj0 = 0 ;
3397 PyObject * obj1 = 0 ;
3398 char *kwnames[] = {
3399 (char *) "w",(char *) "h", NULL
3400 };
3401
3402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3403 if (obj0) {
3404 {
3405 arg1 = (int)(SWIG_As_int(obj0));
3406 if (SWIG_arg_fail(1)) SWIG_fail;
3407 }
3408 }
3409 if (obj1) {
3410 {
3411 arg2 = (int)(SWIG_As_int(obj1));
3412 if (SWIG_arg_fail(2)) SWIG_fail;
3413 }
3414 }
3415 {
3416 PyThreadState* __tstate = wxPyBeginAllowThreads();
3417 result = (wxSize *)new wxSize(arg1,arg2);
3418
3419 wxPyEndAllowThreads(__tstate);
3420 if (PyErr_Occurred()) SWIG_fail;
3421 }
3422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3423 return resultobj;
3424 fail:
3425 return NULL;
3426 }
3427
3428
3429 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3430 PyObject *resultobj;
3431 wxSize *arg1 = (wxSize *) 0 ;
3432 PyObject * obj0 = 0 ;
3433 char *kwnames[] = {
3434 (char *) "self", NULL
3435 };
3436
3437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3439 if (SWIG_arg_fail(1)) SWIG_fail;
3440 {
3441 PyThreadState* __tstate = wxPyBeginAllowThreads();
3442 delete arg1;
3443
3444 wxPyEndAllowThreads(__tstate);
3445 if (PyErr_Occurred()) SWIG_fail;
3446 }
3447 Py_INCREF(Py_None); resultobj = Py_None;
3448 return resultobj;
3449 fail:
3450 return NULL;
3451 }
3452
3453
3454 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3455 PyObject *resultobj;
3456 wxSize *arg1 = (wxSize *) 0 ;
3457 wxSize *arg2 = 0 ;
3458 bool result;
3459 wxSize temp2 ;
3460 PyObject * obj0 = 0 ;
3461 PyObject * obj1 = 0 ;
3462 char *kwnames[] = {
3463 (char *) "self",(char *) "sz", NULL
3464 };
3465
3466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3468 if (SWIG_arg_fail(1)) SWIG_fail;
3469 {
3470 arg2 = &temp2;
3471 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3472 }
3473 {
3474 PyThreadState* __tstate = wxPyBeginAllowThreads();
3475 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3476
3477 wxPyEndAllowThreads(__tstate);
3478 if (PyErr_Occurred()) SWIG_fail;
3479 }
3480 {
3481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3482 }
3483 return resultobj;
3484 fail:
3485 return NULL;
3486 }
3487
3488
3489 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3490 PyObject *resultobj;
3491 wxSize *arg1 = (wxSize *) 0 ;
3492 wxSize *arg2 = 0 ;
3493 bool result;
3494 wxSize temp2 ;
3495 PyObject * obj0 = 0 ;
3496 PyObject * obj1 = 0 ;
3497 char *kwnames[] = {
3498 (char *) "self",(char *) "sz", NULL
3499 };
3500
3501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3503 if (SWIG_arg_fail(1)) SWIG_fail;
3504 {
3505 arg2 = &temp2;
3506 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3507 }
3508 {
3509 PyThreadState* __tstate = wxPyBeginAllowThreads();
3510 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3511
3512 wxPyEndAllowThreads(__tstate);
3513 if (PyErr_Occurred()) SWIG_fail;
3514 }
3515 {
3516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3517 }
3518 return resultobj;
3519 fail:
3520 return NULL;
3521 }
3522
3523
3524 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3525 PyObject *resultobj;
3526 wxSize *arg1 = (wxSize *) 0 ;
3527 wxSize *arg2 = 0 ;
3528 wxSize result;
3529 wxSize temp2 ;
3530 PyObject * obj0 = 0 ;
3531 PyObject * obj1 = 0 ;
3532 char *kwnames[] = {
3533 (char *) "self",(char *) "sz", NULL
3534 };
3535
3536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3538 if (SWIG_arg_fail(1)) SWIG_fail;
3539 {
3540 arg2 = &temp2;
3541 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3542 }
3543 {
3544 PyThreadState* __tstate = wxPyBeginAllowThreads();
3545 result = (arg1)->operator +((wxSize const &)*arg2);
3546
3547 wxPyEndAllowThreads(__tstate);
3548 if (PyErr_Occurred()) SWIG_fail;
3549 }
3550 {
3551 wxSize * resultptr;
3552 resultptr = new wxSize((wxSize &)(result));
3553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3554 }
3555 return resultobj;
3556 fail:
3557 return NULL;
3558 }
3559
3560
3561 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3562 PyObject *resultobj;
3563 wxSize *arg1 = (wxSize *) 0 ;
3564 wxSize *arg2 = 0 ;
3565 wxSize result;
3566 wxSize temp2 ;
3567 PyObject * obj0 = 0 ;
3568 PyObject * obj1 = 0 ;
3569 char *kwnames[] = {
3570 (char *) "self",(char *) "sz", NULL
3571 };
3572
3573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3575 if (SWIG_arg_fail(1)) SWIG_fail;
3576 {
3577 arg2 = &temp2;
3578 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3579 }
3580 {
3581 PyThreadState* __tstate = wxPyBeginAllowThreads();
3582 result = (arg1)->operator -((wxSize const &)*arg2);
3583
3584 wxPyEndAllowThreads(__tstate);
3585 if (PyErr_Occurred()) SWIG_fail;
3586 }
3587 {
3588 wxSize * resultptr;
3589 resultptr = new wxSize((wxSize &)(result));
3590 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3591 }
3592 return resultobj;
3593 fail:
3594 return NULL;
3595 }
3596
3597
3598 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3599 PyObject *resultobj;
3600 wxSize *arg1 = (wxSize *) 0 ;
3601 wxSize *arg2 = 0 ;
3602 wxSize temp2 ;
3603 PyObject * obj0 = 0 ;
3604 PyObject * obj1 = 0 ;
3605 char *kwnames[] = {
3606 (char *) "self",(char *) "sz", NULL
3607 };
3608
3609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3611 if (SWIG_arg_fail(1)) SWIG_fail;
3612 {
3613 arg2 = &temp2;
3614 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3615 }
3616 {
3617 PyThreadState* __tstate = wxPyBeginAllowThreads();
3618 (arg1)->IncTo((wxSize const &)*arg2);
3619
3620 wxPyEndAllowThreads(__tstate);
3621 if (PyErr_Occurred()) SWIG_fail;
3622 }
3623 Py_INCREF(Py_None); resultobj = Py_None;
3624 return resultobj;
3625 fail:
3626 return NULL;
3627 }
3628
3629
3630 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3631 PyObject *resultobj;
3632 wxSize *arg1 = (wxSize *) 0 ;
3633 wxSize *arg2 = 0 ;
3634 wxSize temp2 ;
3635 PyObject * obj0 = 0 ;
3636 PyObject * obj1 = 0 ;
3637 char *kwnames[] = {
3638 (char *) "self",(char *) "sz", NULL
3639 };
3640
3641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3643 if (SWIG_arg_fail(1)) SWIG_fail;
3644 {
3645 arg2 = &temp2;
3646 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3647 }
3648 {
3649 PyThreadState* __tstate = wxPyBeginAllowThreads();
3650 (arg1)->DecTo((wxSize const &)*arg2);
3651
3652 wxPyEndAllowThreads(__tstate);
3653 if (PyErr_Occurred()) SWIG_fail;
3654 }
3655 Py_INCREF(Py_None); resultobj = Py_None;
3656 return resultobj;
3657 fail:
3658 return NULL;
3659 }
3660
3661
3662 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3663 PyObject *resultobj;
3664 wxSize *arg1 = (wxSize *) 0 ;
3665 int arg2 ;
3666 int arg3 ;
3667 PyObject * obj0 = 0 ;
3668 PyObject * obj1 = 0 ;
3669 PyObject * obj2 = 0 ;
3670 char *kwnames[] = {
3671 (char *) "self",(char *) "w",(char *) "h", NULL
3672 };
3673
3674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3676 if (SWIG_arg_fail(1)) SWIG_fail;
3677 {
3678 arg2 = (int)(SWIG_As_int(obj1));
3679 if (SWIG_arg_fail(2)) SWIG_fail;
3680 }
3681 {
3682 arg3 = (int)(SWIG_As_int(obj2));
3683 if (SWIG_arg_fail(3)) SWIG_fail;
3684 }
3685 {
3686 PyThreadState* __tstate = wxPyBeginAllowThreads();
3687 (arg1)->Set(arg2,arg3);
3688
3689 wxPyEndAllowThreads(__tstate);
3690 if (PyErr_Occurred()) SWIG_fail;
3691 }
3692 Py_INCREF(Py_None); resultobj = Py_None;
3693 return resultobj;
3694 fail:
3695 return NULL;
3696 }
3697
3698
3699 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3700 PyObject *resultobj;
3701 wxSize *arg1 = (wxSize *) 0 ;
3702 int arg2 ;
3703 PyObject * obj0 = 0 ;
3704 PyObject * obj1 = 0 ;
3705 char *kwnames[] = {
3706 (char *) "self",(char *) "w", NULL
3707 };
3708
3709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3711 if (SWIG_arg_fail(1)) SWIG_fail;
3712 {
3713 arg2 = (int)(SWIG_As_int(obj1));
3714 if (SWIG_arg_fail(2)) SWIG_fail;
3715 }
3716 {
3717 PyThreadState* __tstate = wxPyBeginAllowThreads();
3718 (arg1)->SetWidth(arg2);
3719
3720 wxPyEndAllowThreads(__tstate);
3721 if (PyErr_Occurred()) SWIG_fail;
3722 }
3723 Py_INCREF(Py_None); resultobj = Py_None;
3724 return resultobj;
3725 fail:
3726 return NULL;
3727 }
3728
3729
3730 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3731 PyObject *resultobj;
3732 wxSize *arg1 = (wxSize *) 0 ;
3733 int arg2 ;
3734 PyObject * obj0 = 0 ;
3735 PyObject * obj1 = 0 ;
3736 char *kwnames[] = {
3737 (char *) "self",(char *) "h", NULL
3738 };
3739
3740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3742 if (SWIG_arg_fail(1)) SWIG_fail;
3743 {
3744 arg2 = (int)(SWIG_As_int(obj1));
3745 if (SWIG_arg_fail(2)) SWIG_fail;
3746 }
3747 {
3748 PyThreadState* __tstate = wxPyBeginAllowThreads();
3749 (arg1)->SetHeight(arg2);
3750
3751 wxPyEndAllowThreads(__tstate);
3752 if (PyErr_Occurred()) SWIG_fail;
3753 }
3754 Py_INCREF(Py_None); resultobj = Py_None;
3755 return resultobj;
3756 fail:
3757 return NULL;
3758 }
3759
3760
3761 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3762 PyObject *resultobj;
3763 wxSize *arg1 = (wxSize *) 0 ;
3764 int result;
3765 PyObject * obj0 = 0 ;
3766 char *kwnames[] = {
3767 (char *) "self", NULL
3768 };
3769
3770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3772 if (SWIG_arg_fail(1)) SWIG_fail;
3773 {
3774 PyThreadState* __tstate = wxPyBeginAllowThreads();
3775 result = (int)((wxSize const *)arg1)->GetWidth();
3776
3777 wxPyEndAllowThreads(__tstate);
3778 if (PyErr_Occurred()) SWIG_fail;
3779 }
3780 {
3781 resultobj = SWIG_From_int((int)(result));
3782 }
3783 return resultobj;
3784 fail:
3785 return NULL;
3786 }
3787
3788
3789 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3790 PyObject *resultobj;
3791 wxSize *arg1 = (wxSize *) 0 ;
3792 int result;
3793 PyObject * obj0 = 0 ;
3794 char *kwnames[] = {
3795 (char *) "self", NULL
3796 };
3797
3798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3800 if (SWIG_arg_fail(1)) SWIG_fail;
3801 {
3802 PyThreadState* __tstate = wxPyBeginAllowThreads();
3803 result = (int)((wxSize const *)arg1)->GetHeight();
3804
3805 wxPyEndAllowThreads(__tstate);
3806 if (PyErr_Occurred()) SWIG_fail;
3807 }
3808 {
3809 resultobj = SWIG_From_int((int)(result));
3810 }
3811 return resultobj;
3812 fail:
3813 return NULL;
3814 }
3815
3816
3817 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3818 PyObject *resultobj;
3819 wxSize *arg1 = (wxSize *) 0 ;
3820 bool result;
3821 PyObject * obj0 = 0 ;
3822 char *kwnames[] = {
3823 (char *) "self", NULL
3824 };
3825
3826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3828 if (SWIG_arg_fail(1)) SWIG_fail;
3829 {
3830 PyThreadState* __tstate = wxPyBeginAllowThreads();
3831 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3832
3833 wxPyEndAllowThreads(__tstate);
3834 if (PyErr_Occurred()) SWIG_fail;
3835 }
3836 {
3837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3838 }
3839 return resultobj;
3840 fail:
3841 return NULL;
3842 }
3843
3844
3845 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3846 PyObject *resultobj;
3847 wxSize *arg1 = (wxSize *) 0 ;
3848 wxSize *arg2 = 0 ;
3849 wxSize temp2 ;
3850 PyObject * obj0 = 0 ;
3851 PyObject * obj1 = 0 ;
3852 char *kwnames[] = {
3853 (char *) "self",(char *) "size", NULL
3854 };
3855
3856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3858 if (SWIG_arg_fail(1)) SWIG_fail;
3859 {
3860 arg2 = &temp2;
3861 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3862 }
3863 {
3864 PyThreadState* __tstate = wxPyBeginAllowThreads();
3865 (arg1)->SetDefaults((wxSize const &)*arg2);
3866
3867 wxPyEndAllowThreads(__tstate);
3868 if (PyErr_Occurred()) SWIG_fail;
3869 }
3870 Py_INCREF(Py_None); resultobj = Py_None;
3871 return resultobj;
3872 fail:
3873 return NULL;
3874 }
3875
3876
3877 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3878 PyObject *resultobj;
3879 wxSize *arg1 = (wxSize *) 0 ;
3880 PyObject *result;
3881 PyObject * obj0 = 0 ;
3882 char *kwnames[] = {
3883 (char *) "self", NULL
3884 };
3885
3886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3888 if (SWIG_arg_fail(1)) SWIG_fail;
3889 {
3890 PyThreadState* __tstate = wxPyBeginAllowThreads();
3891 result = (PyObject *)wxSize_Get(arg1);
3892
3893 wxPyEndAllowThreads(__tstate);
3894 if (PyErr_Occurred()) SWIG_fail;
3895 }
3896 resultobj = result;
3897 return resultobj;
3898 fail:
3899 return NULL;
3900 }
3901
3902
3903 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3904 PyObject *obj;
3905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3906 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3907 Py_INCREF(obj);
3908 return Py_BuildValue((char *)"");
3909 }
3910 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3911 PyObject *resultobj;
3912 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3913 double arg2 ;
3914 PyObject * obj0 = 0 ;
3915 PyObject * obj1 = 0 ;
3916 char *kwnames[] = {
3917 (char *) "self",(char *) "x", NULL
3918 };
3919
3920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3922 if (SWIG_arg_fail(1)) SWIG_fail;
3923 {
3924 arg2 = (double)(SWIG_As_double(obj1));
3925 if (SWIG_arg_fail(2)) SWIG_fail;
3926 }
3927 if (arg1) (arg1)->x = arg2;
3928
3929 Py_INCREF(Py_None); resultobj = Py_None;
3930 return resultobj;
3931 fail:
3932 return NULL;
3933 }
3934
3935
3936 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3937 PyObject *resultobj;
3938 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3939 double result;
3940 PyObject * obj0 = 0 ;
3941 char *kwnames[] = {
3942 (char *) "self", NULL
3943 };
3944
3945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3947 if (SWIG_arg_fail(1)) SWIG_fail;
3948 result = (double) ((arg1)->x);
3949
3950 {
3951 resultobj = SWIG_From_double((double)(result));
3952 }
3953 return resultobj;
3954 fail:
3955 return NULL;
3956 }
3957
3958
3959 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3960 PyObject *resultobj;
3961 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3962 double arg2 ;
3963 PyObject * obj0 = 0 ;
3964 PyObject * obj1 = 0 ;
3965 char *kwnames[] = {
3966 (char *) "self",(char *) "y", NULL
3967 };
3968
3969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3971 if (SWIG_arg_fail(1)) SWIG_fail;
3972 {
3973 arg2 = (double)(SWIG_As_double(obj1));
3974 if (SWIG_arg_fail(2)) SWIG_fail;
3975 }
3976 if (arg1) (arg1)->y = arg2;
3977
3978 Py_INCREF(Py_None); resultobj = Py_None;
3979 return resultobj;
3980 fail:
3981 return NULL;
3982 }
3983
3984
3985 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3986 PyObject *resultobj;
3987 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3988 double result;
3989 PyObject * obj0 = 0 ;
3990 char *kwnames[] = {
3991 (char *) "self", NULL
3992 };
3993
3994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
3995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3996 if (SWIG_arg_fail(1)) SWIG_fail;
3997 result = (double) ((arg1)->y);
3998
3999 {
4000 resultobj = SWIG_From_double((double)(result));
4001 }
4002 return resultobj;
4003 fail:
4004 return NULL;
4005 }
4006
4007
4008 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4009 PyObject *resultobj;
4010 double arg1 = (double) 0.0 ;
4011 double arg2 = (double) 0.0 ;
4012 wxRealPoint *result;
4013 PyObject * obj0 = 0 ;
4014 PyObject * obj1 = 0 ;
4015 char *kwnames[] = {
4016 (char *) "x",(char *) "y", NULL
4017 };
4018
4019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4020 if (obj0) {
4021 {
4022 arg1 = (double)(SWIG_As_double(obj0));
4023 if (SWIG_arg_fail(1)) SWIG_fail;
4024 }
4025 }
4026 if (obj1) {
4027 {
4028 arg2 = (double)(SWIG_As_double(obj1));
4029 if (SWIG_arg_fail(2)) SWIG_fail;
4030 }
4031 }
4032 {
4033 PyThreadState* __tstate = wxPyBeginAllowThreads();
4034 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4035
4036 wxPyEndAllowThreads(__tstate);
4037 if (PyErr_Occurred()) SWIG_fail;
4038 }
4039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4040 return resultobj;
4041 fail:
4042 return NULL;
4043 }
4044
4045
4046 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4047 PyObject *resultobj;
4048 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4049 PyObject * obj0 = 0 ;
4050 char *kwnames[] = {
4051 (char *) "self", NULL
4052 };
4053
4054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4056 if (SWIG_arg_fail(1)) SWIG_fail;
4057 {
4058 PyThreadState* __tstate = wxPyBeginAllowThreads();
4059 delete arg1;
4060
4061 wxPyEndAllowThreads(__tstate);
4062 if (PyErr_Occurred()) SWIG_fail;
4063 }
4064 Py_INCREF(Py_None); resultobj = Py_None;
4065 return resultobj;
4066 fail:
4067 return NULL;
4068 }
4069
4070
4071 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4072 PyObject *resultobj;
4073 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4074 wxRealPoint *arg2 = 0 ;
4075 bool result;
4076 wxRealPoint temp2 ;
4077 PyObject * obj0 = 0 ;
4078 PyObject * obj1 = 0 ;
4079 char *kwnames[] = {
4080 (char *) "self",(char *) "pt", NULL
4081 };
4082
4083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4085 if (SWIG_arg_fail(1)) SWIG_fail;
4086 {
4087 arg2 = &temp2;
4088 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4089 }
4090 {
4091 PyThreadState* __tstate = wxPyBeginAllowThreads();
4092 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4093
4094 wxPyEndAllowThreads(__tstate);
4095 if (PyErr_Occurred()) SWIG_fail;
4096 }
4097 {
4098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4099 }
4100 return resultobj;
4101 fail:
4102 return NULL;
4103 }
4104
4105
4106 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4107 PyObject *resultobj;
4108 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4109 wxRealPoint *arg2 = 0 ;
4110 bool result;
4111 wxRealPoint temp2 ;
4112 PyObject * obj0 = 0 ;
4113 PyObject * obj1 = 0 ;
4114 char *kwnames[] = {
4115 (char *) "self",(char *) "pt", NULL
4116 };
4117
4118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4120 if (SWIG_arg_fail(1)) SWIG_fail;
4121 {
4122 arg2 = &temp2;
4123 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4124 }
4125 {
4126 PyThreadState* __tstate = wxPyBeginAllowThreads();
4127 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4128
4129 wxPyEndAllowThreads(__tstate);
4130 if (PyErr_Occurred()) SWIG_fail;
4131 }
4132 {
4133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4134 }
4135 return resultobj;
4136 fail:
4137 return NULL;
4138 }
4139
4140
4141 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4142 PyObject *resultobj;
4143 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4144 wxRealPoint *arg2 = 0 ;
4145 wxRealPoint result;
4146 wxRealPoint temp2 ;
4147 PyObject * obj0 = 0 ;
4148 PyObject * obj1 = 0 ;
4149 char *kwnames[] = {
4150 (char *) "self",(char *) "pt", NULL
4151 };
4152
4153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4155 if (SWIG_arg_fail(1)) SWIG_fail;
4156 {
4157 arg2 = &temp2;
4158 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4159 }
4160 {
4161 PyThreadState* __tstate = wxPyBeginAllowThreads();
4162 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4163
4164 wxPyEndAllowThreads(__tstate);
4165 if (PyErr_Occurred()) SWIG_fail;
4166 }
4167 {
4168 wxRealPoint * resultptr;
4169 resultptr = new wxRealPoint((wxRealPoint &)(result));
4170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4171 }
4172 return resultobj;
4173 fail:
4174 return NULL;
4175 }
4176
4177
4178 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4179 PyObject *resultobj;
4180 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4181 wxRealPoint *arg2 = 0 ;
4182 wxRealPoint result;
4183 wxRealPoint temp2 ;
4184 PyObject * obj0 = 0 ;
4185 PyObject * obj1 = 0 ;
4186 char *kwnames[] = {
4187 (char *) "self",(char *) "pt", NULL
4188 };
4189
4190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4192 if (SWIG_arg_fail(1)) SWIG_fail;
4193 {
4194 arg2 = &temp2;
4195 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4196 }
4197 {
4198 PyThreadState* __tstate = wxPyBeginAllowThreads();
4199 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4200
4201 wxPyEndAllowThreads(__tstate);
4202 if (PyErr_Occurred()) SWIG_fail;
4203 }
4204 {
4205 wxRealPoint * resultptr;
4206 resultptr = new wxRealPoint((wxRealPoint &)(result));
4207 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4208 }
4209 return resultobj;
4210 fail:
4211 return NULL;
4212 }
4213
4214
4215 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4216 PyObject *resultobj;
4217 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4218 double arg2 ;
4219 double arg3 ;
4220 PyObject * obj0 = 0 ;
4221 PyObject * obj1 = 0 ;
4222 PyObject * obj2 = 0 ;
4223 char *kwnames[] = {
4224 (char *) "self",(char *) "x",(char *) "y", NULL
4225 };
4226
4227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4229 if (SWIG_arg_fail(1)) SWIG_fail;
4230 {
4231 arg2 = (double)(SWIG_As_double(obj1));
4232 if (SWIG_arg_fail(2)) SWIG_fail;
4233 }
4234 {
4235 arg3 = (double)(SWIG_As_double(obj2));
4236 if (SWIG_arg_fail(3)) SWIG_fail;
4237 }
4238 {
4239 PyThreadState* __tstate = wxPyBeginAllowThreads();
4240 wxRealPoint_Set(arg1,arg2,arg3);
4241
4242 wxPyEndAllowThreads(__tstate);
4243 if (PyErr_Occurred()) SWIG_fail;
4244 }
4245 Py_INCREF(Py_None); resultobj = Py_None;
4246 return resultobj;
4247 fail:
4248 return NULL;
4249 }
4250
4251
4252 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4253 PyObject *resultobj;
4254 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4255 PyObject *result;
4256 PyObject * obj0 = 0 ;
4257 char *kwnames[] = {
4258 (char *) "self", NULL
4259 };
4260
4261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4263 if (SWIG_arg_fail(1)) SWIG_fail;
4264 {
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 result = (PyObject *)wxRealPoint_Get(arg1);
4267
4268 wxPyEndAllowThreads(__tstate);
4269 if (PyErr_Occurred()) SWIG_fail;
4270 }
4271 resultobj = result;
4272 return resultobj;
4273 fail:
4274 return NULL;
4275 }
4276
4277
4278 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4279 PyObject *obj;
4280 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4281 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4282 Py_INCREF(obj);
4283 return Py_BuildValue((char *)"");
4284 }
4285 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4286 PyObject *resultobj;
4287 wxPoint *arg1 = (wxPoint *) 0 ;
4288 int arg2 ;
4289 PyObject * obj0 = 0 ;
4290 PyObject * obj1 = 0 ;
4291 char *kwnames[] = {
4292 (char *) "self",(char *) "x", NULL
4293 };
4294
4295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4297 if (SWIG_arg_fail(1)) SWIG_fail;
4298 {
4299 arg2 = (int)(SWIG_As_int(obj1));
4300 if (SWIG_arg_fail(2)) SWIG_fail;
4301 }
4302 if (arg1) (arg1)->x = arg2;
4303
4304 Py_INCREF(Py_None); resultobj = Py_None;
4305 return resultobj;
4306 fail:
4307 return NULL;
4308 }
4309
4310
4311 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4312 PyObject *resultobj;
4313 wxPoint *arg1 = (wxPoint *) 0 ;
4314 int result;
4315 PyObject * obj0 = 0 ;
4316 char *kwnames[] = {
4317 (char *) "self", NULL
4318 };
4319
4320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4322 if (SWIG_arg_fail(1)) SWIG_fail;
4323 result = (int) ((arg1)->x);
4324
4325 {
4326 resultobj = SWIG_From_int((int)(result));
4327 }
4328 return resultobj;
4329 fail:
4330 return NULL;
4331 }
4332
4333
4334 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4335 PyObject *resultobj;
4336 wxPoint *arg1 = (wxPoint *) 0 ;
4337 int arg2 ;
4338 PyObject * obj0 = 0 ;
4339 PyObject * obj1 = 0 ;
4340 char *kwnames[] = {
4341 (char *) "self",(char *) "y", NULL
4342 };
4343
4344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4346 if (SWIG_arg_fail(1)) SWIG_fail;
4347 {
4348 arg2 = (int)(SWIG_As_int(obj1));
4349 if (SWIG_arg_fail(2)) SWIG_fail;
4350 }
4351 if (arg1) (arg1)->y = arg2;
4352
4353 Py_INCREF(Py_None); resultobj = Py_None;
4354 return resultobj;
4355 fail:
4356 return NULL;
4357 }
4358
4359
4360 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4361 PyObject *resultobj;
4362 wxPoint *arg1 = (wxPoint *) 0 ;
4363 int result;
4364 PyObject * obj0 = 0 ;
4365 char *kwnames[] = {
4366 (char *) "self", NULL
4367 };
4368
4369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4371 if (SWIG_arg_fail(1)) SWIG_fail;
4372 result = (int) ((arg1)->y);
4373
4374 {
4375 resultobj = SWIG_From_int((int)(result));
4376 }
4377 return resultobj;
4378 fail:
4379 return NULL;
4380 }
4381
4382
4383 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4384 PyObject *resultobj;
4385 int arg1 = (int) 0 ;
4386 int arg2 = (int) 0 ;
4387 wxPoint *result;
4388 PyObject * obj0 = 0 ;
4389 PyObject * obj1 = 0 ;
4390 char *kwnames[] = {
4391 (char *) "x",(char *) "y", NULL
4392 };
4393
4394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4395 if (obj0) {
4396 {
4397 arg1 = (int)(SWIG_As_int(obj0));
4398 if (SWIG_arg_fail(1)) SWIG_fail;
4399 }
4400 }
4401 if (obj1) {
4402 {
4403 arg2 = (int)(SWIG_As_int(obj1));
4404 if (SWIG_arg_fail(2)) SWIG_fail;
4405 }
4406 }
4407 {
4408 PyThreadState* __tstate = wxPyBeginAllowThreads();
4409 result = (wxPoint *)new wxPoint(arg1,arg2);
4410
4411 wxPyEndAllowThreads(__tstate);
4412 if (PyErr_Occurred()) SWIG_fail;
4413 }
4414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4415 return resultobj;
4416 fail:
4417 return NULL;
4418 }
4419
4420
4421 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4422 PyObject *resultobj;
4423 wxPoint *arg1 = (wxPoint *) 0 ;
4424 PyObject * obj0 = 0 ;
4425 char *kwnames[] = {
4426 (char *) "self", NULL
4427 };
4428
4429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4431 if (SWIG_arg_fail(1)) SWIG_fail;
4432 {
4433 PyThreadState* __tstate = wxPyBeginAllowThreads();
4434 delete arg1;
4435
4436 wxPyEndAllowThreads(__tstate);
4437 if (PyErr_Occurred()) SWIG_fail;
4438 }
4439 Py_INCREF(Py_None); resultobj = Py_None;
4440 return resultobj;
4441 fail:
4442 return NULL;
4443 }
4444
4445
4446 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4447 PyObject *resultobj;
4448 wxPoint *arg1 = (wxPoint *) 0 ;
4449 wxPoint *arg2 = 0 ;
4450 bool result;
4451 wxPoint temp2 ;
4452 PyObject * obj0 = 0 ;
4453 PyObject * obj1 = 0 ;
4454 char *kwnames[] = {
4455 (char *) "self",(char *) "pt", NULL
4456 };
4457
4458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4460 if (SWIG_arg_fail(1)) SWIG_fail;
4461 {
4462 arg2 = &temp2;
4463 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4464 }
4465 {
4466 PyThreadState* __tstate = wxPyBeginAllowThreads();
4467 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4468
4469 wxPyEndAllowThreads(__tstate);
4470 if (PyErr_Occurred()) SWIG_fail;
4471 }
4472 {
4473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4474 }
4475 return resultobj;
4476 fail:
4477 return NULL;
4478 }
4479
4480
4481 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4482 PyObject *resultobj;
4483 wxPoint *arg1 = (wxPoint *) 0 ;
4484 wxPoint *arg2 = 0 ;
4485 bool result;
4486 wxPoint temp2 ;
4487 PyObject * obj0 = 0 ;
4488 PyObject * obj1 = 0 ;
4489 char *kwnames[] = {
4490 (char *) "self",(char *) "pt", NULL
4491 };
4492
4493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4495 if (SWIG_arg_fail(1)) SWIG_fail;
4496 {
4497 arg2 = &temp2;
4498 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4499 }
4500 {
4501 PyThreadState* __tstate = wxPyBeginAllowThreads();
4502 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4503
4504 wxPyEndAllowThreads(__tstate);
4505 if (PyErr_Occurred()) SWIG_fail;
4506 }
4507 {
4508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4509 }
4510 return resultobj;
4511 fail:
4512 return NULL;
4513 }
4514
4515
4516 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4517 PyObject *resultobj;
4518 wxPoint *arg1 = (wxPoint *) 0 ;
4519 wxPoint *arg2 = 0 ;
4520 wxPoint result;
4521 wxPoint temp2 ;
4522 PyObject * obj0 = 0 ;
4523 PyObject * obj1 = 0 ;
4524 char *kwnames[] = {
4525 (char *) "self",(char *) "pt", NULL
4526 };
4527
4528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4530 if (SWIG_arg_fail(1)) SWIG_fail;
4531 {
4532 arg2 = &temp2;
4533 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4534 }
4535 {
4536 PyThreadState* __tstate = wxPyBeginAllowThreads();
4537 result = (arg1)->operator +((wxPoint const &)*arg2);
4538
4539 wxPyEndAllowThreads(__tstate);
4540 if (PyErr_Occurred()) SWIG_fail;
4541 }
4542 {
4543 wxPoint * resultptr;
4544 resultptr = new wxPoint((wxPoint &)(result));
4545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4546 }
4547 return resultobj;
4548 fail:
4549 return NULL;
4550 }
4551
4552
4553 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4554 PyObject *resultobj;
4555 wxPoint *arg1 = (wxPoint *) 0 ;
4556 wxPoint *arg2 = 0 ;
4557 wxPoint result;
4558 wxPoint temp2 ;
4559 PyObject * obj0 = 0 ;
4560 PyObject * obj1 = 0 ;
4561 char *kwnames[] = {
4562 (char *) "self",(char *) "pt", NULL
4563 };
4564
4565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4567 if (SWIG_arg_fail(1)) SWIG_fail;
4568 {
4569 arg2 = &temp2;
4570 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4571 }
4572 {
4573 PyThreadState* __tstate = wxPyBeginAllowThreads();
4574 result = (arg1)->operator -((wxPoint const &)*arg2);
4575
4576 wxPyEndAllowThreads(__tstate);
4577 if (PyErr_Occurred()) SWIG_fail;
4578 }
4579 {
4580 wxPoint * resultptr;
4581 resultptr = new wxPoint((wxPoint &)(result));
4582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4583 }
4584 return resultobj;
4585 fail:
4586 return NULL;
4587 }
4588
4589
4590 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4591 PyObject *resultobj;
4592 wxPoint *arg1 = (wxPoint *) 0 ;
4593 wxPoint *arg2 = 0 ;
4594 wxPoint *result;
4595 wxPoint temp2 ;
4596 PyObject * obj0 = 0 ;
4597 PyObject * obj1 = 0 ;
4598 char *kwnames[] = {
4599 (char *) "self",(char *) "pt", NULL
4600 };
4601
4602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4604 if (SWIG_arg_fail(1)) SWIG_fail;
4605 {
4606 arg2 = &temp2;
4607 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4608 }
4609 {
4610 PyThreadState* __tstate = wxPyBeginAllowThreads();
4611 {
4612 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4613 result = (wxPoint *) &_result_ref;
4614 }
4615
4616 wxPyEndAllowThreads(__tstate);
4617 if (PyErr_Occurred()) SWIG_fail;
4618 }
4619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4620 return resultobj;
4621 fail:
4622 return NULL;
4623 }
4624
4625
4626 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4627 PyObject *resultobj;
4628 wxPoint *arg1 = (wxPoint *) 0 ;
4629 wxPoint *arg2 = 0 ;
4630 wxPoint *result;
4631 wxPoint temp2 ;
4632 PyObject * obj0 = 0 ;
4633 PyObject * obj1 = 0 ;
4634 char *kwnames[] = {
4635 (char *) "self",(char *) "pt", NULL
4636 };
4637
4638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4640 if (SWIG_arg_fail(1)) SWIG_fail;
4641 {
4642 arg2 = &temp2;
4643 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4644 }
4645 {
4646 PyThreadState* __tstate = wxPyBeginAllowThreads();
4647 {
4648 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4649 result = (wxPoint *) &_result_ref;
4650 }
4651
4652 wxPyEndAllowThreads(__tstate);
4653 if (PyErr_Occurred()) SWIG_fail;
4654 }
4655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4656 return resultobj;
4657 fail:
4658 return NULL;
4659 }
4660
4661
4662 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj;
4664 wxPoint *arg1 = (wxPoint *) 0 ;
4665 long arg2 ;
4666 long arg3 ;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 PyObject * obj2 = 0 ;
4670 char *kwnames[] = {
4671 (char *) "self",(char *) "x",(char *) "y", NULL
4672 };
4673
4674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4676 if (SWIG_arg_fail(1)) SWIG_fail;
4677 {
4678 arg2 = (long)(SWIG_As_long(obj1));
4679 if (SWIG_arg_fail(2)) SWIG_fail;
4680 }
4681 {
4682 arg3 = (long)(SWIG_As_long(obj2));
4683 if (SWIG_arg_fail(3)) SWIG_fail;
4684 }
4685 {
4686 PyThreadState* __tstate = wxPyBeginAllowThreads();
4687 wxPoint_Set(arg1,arg2,arg3);
4688
4689 wxPyEndAllowThreads(__tstate);
4690 if (PyErr_Occurred()) SWIG_fail;
4691 }
4692 Py_INCREF(Py_None); resultobj = Py_None;
4693 return resultobj;
4694 fail:
4695 return NULL;
4696 }
4697
4698
4699 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4700 PyObject *resultobj;
4701 wxPoint *arg1 = (wxPoint *) 0 ;
4702 PyObject *result;
4703 PyObject * obj0 = 0 ;
4704 char *kwnames[] = {
4705 (char *) "self", NULL
4706 };
4707
4708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4710 if (SWIG_arg_fail(1)) SWIG_fail;
4711 {
4712 PyThreadState* __tstate = wxPyBeginAllowThreads();
4713 result = (PyObject *)wxPoint_Get(arg1);
4714
4715 wxPyEndAllowThreads(__tstate);
4716 if (PyErr_Occurred()) SWIG_fail;
4717 }
4718 resultobj = result;
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4726 PyObject *obj;
4727 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4728 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4729 Py_INCREF(obj);
4730 return Py_BuildValue((char *)"");
4731 }
4732 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4733 PyObject *resultobj;
4734 int arg1 = (int) 0 ;
4735 int arg2 = (int) 0 ;
4736 int arg3 = (int) 0 ;
4737 int arg4 = (int) 0 ;
4738 wxRect *result;
4739 PyObject * obj0 = 0 ;
4740 PyObject * obj1 = 0 ;
4741 PyObject * obj2 = 0 ;
4742 PyObject * obj3 = 0 ;
4743 char *kwnames[] = {
4744 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4745 };
4746
4747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4748 if (obj0) {
4749 {
4750 arg1 = (int)(SWIG_As_int(obj0));
4751 if (SWIG_arg_fail(1)) SWIG_fail;
4752 }
4753 }
4754 if (obj1) {
4755 {
4756 arg2 = (int)(SWIG_As_int(obj1));
4757 if (SWIG_arg_fail(2)) SWIG_fail;
4758 }
4759 }
4760 if (obj2) {
4761 {
4762 arg3 = (int)(SWIG_As_int(obj2));
4763 if (SWIG_arg_fail(3)) SWIG_fail;
4764 }
4765 }
4766 if (obj3) {
4767 {
4768 arg4 = (int)(SWIG_As_int(obj3));
4769 if (SWIG_arg_fail(4)) SWIG_fail;
4770 }
4771 }
4772 {
4773 PyThreadState* __tstate = wxPyBeginAllowThreads();
4774 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4775
4776 wxPyEndAllowThreads(__tstate);
4777 if (PyErr_Occurred()) SWIG_fail;
4778 }
4779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4780 return resultobj;
4781 fail:
4782 return NULL;
4783 }
4784
4785
4786 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4787 PyObject *resultobj;
4788 wxPoint *arg1 = 0 ;
4789 wxPoint *arg2 = 0 ;
4790 wxRect *result;
4791 wxPoint temp1 ;
4792 wxPoint temp2 ;
4793 PyObject * obj0 = 0 ;
4794 PyObject * obj1 = 0 ;
4795 char *kwnames[] = {
4796 (char *) "topLeft",(char *) "bottomRight", NULL
4797 };
4798
4799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4800 {
4801 arg1 = &temp1;
4802 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4803 }
4804 {
4805 arg2 = &temp2;
4806 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4807 }
4808 {
4809 PyThreadState* __tstate = wxPyBeginAllowThreads();
4810 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4811
4812 wxPyEndAllowThreads(__tstate);
4813 if (PyErr_Occurred()) SWIG_fail;
4814 }
4815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4816 return resultobj;
4817 fail:
4818 return NULL;
4819 }
4820
4821
4822 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4823 PyObject *resultobj;
4824 wxPoint *arg1 = 0 ;
4825 wxSize *arg2 = 0 ;
4826 wxRect *result;
4827 wxPoint temp1 ;
4828 wxSize temp2 ;
4829 PyObject * obj0 = 0 ;
4830 PyObject * obj1 = 0 ;
4831 char *kwnames[] = {
4832 (char *) "pos",(char *) "size", NULL
4833 };
4834
4835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4836 {
4837 arg1 = &temp1;
4838 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4839 }
4840 {
4841 arg2 = &temp2;
4842 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4843 }
4844 {
4845 PyThreadState* __tstate = wxPyBeginAllowThreads();
4846 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4847
4848 wxPyEndAllowThreads(__tstate);
4849 if (PyErr_Occurred()) SWIG_fail;
4850 }
4851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4852 return resultobj;
4853 fail:
4854 return NULL;
4855 }
4856
4857
4858 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4859 PyObject *resultobj;
4860 wxSize *arg1 = 0 ;
4861 wxRect *result;
4862 wxSize temp1 ;
4863 PyObject * obj0 = 0 ;
4864 char *kwnames[] = {
4865 (char *) "size", NULL
4866 };
4867
4868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4869 {
4870 arg1 = &temp1;
4871 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4872 }
4873 {
4874 PyThreadState* __tstate = wxPyBeginAllowThreads();
4875 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4876
4877 wxPyEndAllowThreads(__tstate);
4878 if (PyErr_Occurred()) SWIG_fail;
4879 }
4880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4881 return resultobj;
4882 fail:
4883 return NULL;
4884 }
4885
4886
4887 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4888 PyObject *resultobj;
4889 wxRect *arg1 = (wxRect *) 0 ;
4890 PyObject * obj0 = 0 ;
4891 char *kwnames[] = {
4892 (char *) "self", NULL
4893 };
4894
4895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4897 if (SWIG_arg_fail(1)) SWIG_fail;
4898 {
4899 PyThreadState* __tstate = wxPyBeginAllowThreads();
4900 delete arg1;
4901
4902 wxPyEndAllowThreads(__tstate);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 Py_INCREF(Py_None); resultobj = Py_None;
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4913 PyObject *resultobj;
4914 wxRect *arg1 = (wxRect *) 0 ;
4915 int result;
4916 PyObject * obj0 = 0 ;
4917 char *kwnames[] = {
4918 (char *) "self", NULL
4919 };
4920
4921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4923 if (SWIG_arg_fail(1)) SWIG_fail;
4924 {
4925 PyThreadState* __tstate = wxPyBeginAllowThreads();
4926 result = (int)((wxRect const *)arg1)->GetX();
4927
4928 wxPyEndAllowThreads(__tstate);
4929 if (PyErr_Occurred()) SWIG_fail;
4930 }
4931 {
4932 resultobj = SWIG_From_int((int)(result));
4933 }
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4941 PyObject *resultobj;
4942 wxRect *arg1 = (wxRect *) 0 ;
4943 int arg2 ;
4944 PyObject * obj0 = 0 ;
4945 PyObject * obj1 = 0 ;
4946 char *kwnames[] = {
4947 (char *) "self",(char *) "x", NULL
4948 };
4949
4950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4952 if (SWIG_arg_fail(1)) SWIG_fail;
4953 {
4954 arg2 = (int)(SWIG_As_int(obj1));
4955 if (SWIG_arg_fail(2)) SWIG_fail;
4956 }
4957 {
4958 PyThreadState* __tstate = wxPyBeginAllowThreads();
4959 (arg1)->SetX(arg2);
4960
4961 wxPyEndAllowThreads(__tstate);
4962 if (PyErr_Occurred()) SWIG_fail;
4963 }
4964 Py_INCREF(Py_None); resultobj = Py_None;
4965 return resultobj;
4966 fail:
4967 return NULL;
4968 }
4969
4970
4971 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4972 PyObject *resultobj;
4973 wxRect *arg1 = (wxRect *) 0 ;
4974 int result;
4975 PyObject * obj0 = 0 ;
4976 char *kwnames[] = {
4977 (char *) "self", NULL
4978 };
4979
4980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4982 if (SWIG_arg_fail(1)) SWIG_fail;
4983 {
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 result = (int)(arg1)->GetY();
4986
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 {
4991 resultobj = SWIG_From_int((int)(result));
4992 }
4993 return resultobj;
4994 fail:
4995 return NULL;
4996 }
4997
4998
4999 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5000 PyObject *resultobj;
5001 wxRect *arg1 = (wxRect *) 0 ;
5002 int arg2 ;
5003 PyObject * obj0 = 0 ;
5004 PyObject * obj1 = 0 ;
5005 char *kwnames[] = {
5006 (char *) "self",(char *) "y", NULL
5007 };
5008
5009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5011 if (SWIG_arg_fail(1)) SWIG_fail;
5012 {
5013 arg2 = (int)(SWIG_As_int(obj1));
5014 if (SWIG_arg_fail(2)) SWIG_fail;
5015 }
5016 {
5017 PyThreadState* __tstate = wxPyBeginAllowThreads();
5018 (arg1)->SetY(arg2);
5019
5020 wxPyEndAllowThreads(__tstate);
5021 if (PyErr_Occurred()) SWIG_fail;
5022 }
5023 Py_INCREF(Py_None); resultobj = Py_None;
5024 return resultobj;
5025 fail:
5026 return NULL;
5027 }
5028
5029
5030 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5031 PyObject *resultobj;
5032 wxRect *arg1 = (wxRect *) 0 ;
5033 int result;
5034 PyObject * obj0 = 0 ;
5035 char *kwnames[] = {
5036 (char *) "self", NULL
5037 };
5038
5039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5041 if (SWIG_arg_fail(1)) SWIG_fail;
5042 {
5043 PyThreadState* __tstate = wxPyBeginAllowThreads();
5044 result = (int)((wxRect const *)arg1)->GetWidth();
5045
5046 wxPyEndAllowThreads(__tstate);
5047 if (PyErr_Occurred()) SWIG_fail;
5048 }
5049 {
5050 resultobj = SWIG_From_int((int)(result));
5051 }
5052 return resultobj;
5053 fail:
5054 return NULL;
5055 }
5056
5057
5058 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5059 PyObject *resultobj;
5060 wxRect *arg1 = (wxRect *) 0 ;
5061 int arg2 ;
5062 PyObject * obj0 = 0 ;
5063 PyObject * obj1 = 0 ;
5064 char *kwnames[] = {
5065 (char *) "self",(char *) "w", NULL
5066 };
5067
5068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5070 if (SWIG_arg_fail(1)) SWIG_fail;
5071 {
5072 arg2 = (int)(SWIG_As_int(obj1));
5073 if (SWIG_arg_fail(2)) SWIG_fail;
5074 }
5075 {
5076 PyThreadState* __tstate = wxPyBeginAllowThreads();
5077 (arg1)->SetWidth(arg2);
5078
5079 wxPyEndAllowThreads(__tstate);
5080 if (PyErr_Occurred()) SWIG_fail;
5081 }
5082 Py_INCREF(Py_None); resultobj = Py_None;
5083 return resultobj;
5084 fail:
5085 return NULL;
5086 }
5087
5088
5089 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5090 PyObject *resultobj;
5091 wxRect *arg1 = (wxRect *) 0 ;
5092 int result;
5093 PyObject * obj0 = 0 ;
5094 char *kwnames[] = {
5095 (char *) "self", NULL
5096 };
5097
5098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5100 if (SWIG_arg_fail(1)) SWIG_fail;
5101 {
5102 PyThreadState* __tstate = wxPyBeginAllowThreads();
5103 result = (int)((wxRect const *)arg1)->GetHeight();
5104
5105 wxPyEndAllowThreads(__tstate);
5106 if (PyErr_Occurred()) SWIG_fail;
5107 }
5108 {
5109 resultobj = SWIG_From_int((int)(result));
5110 }
5111 return resultobj;
5112 fail:
5113 return NULL;
5114 }
5115
5116
5117 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5118 PyObject *resultobj;
5119 wxRect *arg1 = (wxRect *) 0 ;
5120 int arg2 ;
5121 PyObject * obj0 = 0 ;
5122 PyObject * obj1 = 0 ;
5123 char *kwnames[] = {
5124 (char *) "self",(char *) "h", NULL
5125 };
5126
5127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5129 if (SWIG_arg_fail(1)) SWIG_fail;
5130 {
5131 arg2 = (int)(SWIG_As_int(obj1));
5132 if (SWIG_arg_fail(2)) SWIG_fail;
5133 }
5134 {
5135 PyThreadState* __tstate = wxPyBeginAllowThreads();
5136 (arg1)->SetHeight(arg2);
5137
5138 wxPyEndAllowThreads(__tstate);
5139 if (PyErr_Occurred()) SWIG_fail;
5140 }
5141 Py_INCREF(Py_None); resultobj = Py_None;
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5149 PyObject *resultobj;
5150 wxRect *arg1 = (wxRect *) 0 ;
5151 wxPoint result;
5152 PyObject * obj0 = 0 ;
5153 char *kwnames[] = {
5154 (char *) "self", NULL
5155 };
5156
5157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5159 if (SWIG_arg_fail(1)) SWIG_fail;
5160 {
5161 PyThreadState* __tstate = wxPyBeginAllowThreads();
5162 result = ((wxRect const *)arg1)->GetPosition();
5163
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 {
5168 wxPoint * resultptr;
5169 resultptr = new wxPoint((wxPoint &)(result));
5170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5171 }
5172 return resultobj;
5173 fail:
5174 return NULL;
5175 }
5176
5177
5178 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5179 PyObject *resultobj;
5180 wxRect *arg1 = (wxRect *) 0 ;
5181 wxPoint *arg2 = 0 ;
5182 wxPoint temp2 ;
5183 PyObject * obj0 = 0 ;
5184 PyObject * obj1 = 0 ;
5185 char *kwnames[] = {
5186 (char *) "self",(char *) "p", NULL
5187 };
5188
5189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5191 if (SWIG_arg_fail(1)) SWIG_fail;
5192 {
5193 arg2 = &temp2;
5194 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5195 }
5196 {
5197 PyThreadState* __tstate = wxPyBeginAllowThreads();
5198 (arg1)->SetPosition((wxPoint const &)*arg2);
5199
5200 wxPyEndAllowThreads(__tstate);
5201 if (PyErr_Occurred()) SWIG_fail;
5202 }
5203 Py_INCREF(Py_None); resultobj = Py_None;
5204 return resultobj;
5205 fail:
5206 return NULL;
5207 }
5208
5209
5210 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5211 PyObject *resultobj;
5212 wxRect *arg1 = (wxRect *) 0 ;
5213 wxSize result;
5214 PyObject * obj0 = 0 ;
5215 char *kwnames[] = {
5216 (char *) "self", NULL
5217 };
5218
5219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5221 if (SWIG_arg_fail(1)) SWIG_fail;
5222 {
5223 PyThreadState* __tstate = wxPyBeginAllowThreads();
5224 result = ((wxRect const *)arg1)->GetSize();
5225
5226 wxPyEndAllowThreads(__tstate);
5227 if (PyErr_Occurred()) SWIG_fail;
5228 }
5229 {
5230 wxSize * resultptr;
5231 resultptr = new wxSize((wxSize &)(result));
5232 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5233 }
5234 return resultobj;
5235 fail:
5236 return NULL;
5237 }
5238
5239
5240 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5241 PyObject *resultobj;
5242 wxRect *arg1 = (wxRect *) 0 ;
5243 wxSize *arg2 = 0 ;
5244 wxSize temp2 ;
5245 PyObject * obj0 = 0 ;
5246 PyObject * obj1 = 0 ;
5247 char *kwnames[] = {
5248 (char *) "self",(char *) "s", NULL
5249 };
5250
5251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5253 if (SWIG_arg_fail(1)) SWIG_fail;
5254 {
5255 arg2 = &temp2;
5256 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5257 }
5258 {
5259 PyThreadState* __tstate = wxPyBeginAllowThreads();
5260 (arg1)->SetSize((wxSize const &)*arg2);
5261
5262 wxPyEndAllowThreads(__tstate);
5263 if (PyErr_Occurred()) SWIG_fail;
5264 }
5265 Py_INCREF(Py_None); resultobj = Py_None;
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
5272 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5273 PyObject *resultobj;
5274 wxRect *arg1 = (wxRect *) 0 ;
5275 wxPoint result;
5276 PyObject * obj0 = 0 ;
5277 char *kwnames[] = {
5278 (char *) "self", NULL
5279 };
5280
5281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5283 if (SWIG_arg_fail(1)) SWIG_fail;
5284 {
5285 PyThreadState* __tstate = wxPyBeginAllowThreads();
5286 result = ((wxRect const *)arg1)->GetTopLeft();
5287
5288 wxPyEndAllowThreads(__tstate);
5289 if (PyErr_Occurred()) SWIG_fail;
5290 }
5291 {
5292 wxPoint * resultptr;
5293 resultptr = new wxPoint((wxPoint &)(result));
5294 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5295 }
5296 return resultobj;
5297 fail:
5298 return NULL;
5299 }
5300
5301
5302 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5303 PyObject *resultobj;
5304 wxRect *arg1 = (wxRect *) 0 ;
5305 wxPoint *arg2 = 0 ;
5306 wxPoint temp2 ;
5307 PyObject * obj0 = 0 ;
5308 PyObject * obj1 = 0 ;
5309 char *kwnames[] = {
5310 (char *) "self",(char *) "p", NULL
5311 };
5312
5313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5315 if (SWIG_arg_fail(1)) SWIG_fail;
5316 {
5317 arg2 = &temp2;
5318 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5319 }
5320 {
5321 PyThreadState* __tstate = wxPyBeginAllowThreads();
5322 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5323
5324 wxPyEndAllowThreads(__tstate);
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 Py_INCREF(Py_None); resultobj = Py_None;
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5335 PyObject *resultobj;
5336 wxRect *arg1 = (wxRect *) 0 ;
5337 wxPoint result;
5338 PyObject * obj0 = 0 ;
5339 char *kwnames[] = {
5340 (char *) "self", NULL
5341 };
5342
5343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5345 if (SWIG_arg_fail(1)) SWIG_fail;
5346 {
5347 PyThreadState* __tstate = wxPyBeginAllowThreads();
5348 result = ((wxRect const *)arg1)->GetBottomRight();
5349
5350 wxPyEndAllowThreads(__tstate);
5351 if (PyErr_Occurred()) SWIG_fail;
5352 }
5353 {
5354 wxPoint * resultptr;
5355 resultptr = new wxPoint((wxPoint &)(result));
5356 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5357 }
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5365 PyObject *resultobj;
5366 wxRect *arg1 = (wxRect *) 0 ;
5367 wxPoint *arg2 = 0 ;
5368 wxPoint temp2 ;
5369 PyObject * obj0 = 0 ;
5370 PyObject * obj1 = 0 ;
5371 char *kwnames[] = {
5372 (char *) "self",(char *) "p", NULL
5373 };
5374
5375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5377 if (SWIG_arg_fail(1)) SWIG_fail;
5378 {
5379 arg2 = &temp2;
5380 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5381 }
5382 {
5383 PyThreadState* __tstate = wxPyBeginAllowThreads();
5384 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5385
5386 wxPyEndAllowThreads(__tstate);
5387 if (PyErr_Occurred()) SWIG_fail;
5388 }
5389 Py_INCREF(Py_None); resultobj = Py_None;
5390 return resultobj;
5391 fail:
5392 return NULL;
5393 }
5394
5395
5396 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5397 PyObject *resultobj;
5398 wxRect *arg1 = (wxRect *) 0 ;
5399 int result;
5400 PyObject * obj0 = 0 ;
5401 char *kwnames[] = {
5402 (char *) "self", NULL
5403 };
5404
5405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5407 if (SWIG_arg_fail(1)) SWIG_fail;
5408 {
5409 PyThreadState* __tstate = wxPyBeginAllowThreads();
5410 result = (int)((wxRect const *)arg1)->GetLeft();
5411
5412 wxPyEndAllowThreads(__tstate);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 {
5416 resultobj = SWIG_From_int((int)(result));
5417 }
5418 return resultobj;
5419 fail:
5420 return NULL;
5421 }
5422
5423
5424 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5425 PyObject *resultobj;
5426 wxRect *arg1 = (wxRect *) 0 ;
5427 int result;
5428 PyObject * obj0 = 0 ;
5429 char *kwnames[] = {
5430 (char *) "self", NULL
5431 };
5432
5433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5435 if (SWIG_arg_fail(1)) SWIG_fail;
5436 {
5437 PyThreadState* __tstate = wxPyBeginAllowThreads();
5438 result = (int)((wxRect const *)arg1)->GetTop();
5439
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 {
5444 resultobj = SWIG_From_int((int)(result));
5445 }
5446 return resultobj;
5447 fail:
5448 return NULL;
5449 }
5450
5451
5452 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5453 PyObject *resultobj;
5454 wxRect *arg1 = (wxRect *) 0 ;
5455 int result;
5456 PyObject * obj0 = 0 ;
5457 char *kwnames[] = {
5458 (char *) "self", NULL
5459 };
5460
5461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5463 if (SWIG_arg_fail(1)) SWIG_fail;
5464 {
5465 PyThreadState* __tstate = wxPyBeginAllowThreads();
5466 result = (int)((wxRect const *)arg1)->GetBottom();
5467
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 {
5472 resultobj = SWIG_From_int((int)(result));
5473 }
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5481 PyObject *resultobj;
5482 wxRect *arg1 = (wxRect *) 0 ;
5483 int result;
5484 PyObject * obj0 = 0 ;
5485 char *kwnames[] = {
5486 (char *) "self", NULL
5487 };
5488
5489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5491 if (SWIG_arg_fail(1)) SWIG_fail;
5492 {
5493 PyThreadState* __tstate = wxPyBeginAllowThreads();
5494 result = (int)((wxRect const *)arg1)->GetRight();
5495
5496 wxPyEndAllowThreads(__tstate);
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 {
5500 resultobj = SWIG_From_int((int)(result));
5501 }
5502 return resultobj;
5503 fail:
5504 return NULL;
5505 }
5506
5507
5508 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5509 PyObject *resultobj;
5510 wxRect *arg1 = (wxRect *) 0 ;
5511 int arg2 ;
5512 PyObject * obj0 = 0 ;
5513 PyObject * obj1 = 0 ;
5514 char *kwnames[] = {
5515 (char *) "self",(char *) "left", NULL
5516 };
5517
5518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5520 if (SWIG_arg_fail(1)) SWIG_fail;
5521 {
5522 arg2 = (int)(SWIG_As_int(obj1));
5523 if (SWIG_arg_fail(2)) SWIG_fail;
5524 }
5525 {
5526 PyThreadState* __tstate = wxPyBeginAllowThreads();
5527 (arg1)->SetLeft(arg2);
5528
5529 wxPyEndAllowThreads(__tstate);
5530 if (PyErr_Occurred()) SWIG_fail;
5531 }
5532 Py_INCREF(Py_None); resultobj = Py_None;
5533 return resultobj;
5534 fail:
5535 return NULL;
5536 }
5537
5538
5539 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5540 PyObject *resultobj;
5541 wxRect *arg1 = (wxRect *) 0 ;
5542 int arg2 ;
5543 PyObject * obj0 = 0 ;
5544 PyObject * obj1 = 0 ;
5545 char *kwnames[] = {
5546 (char *) "self",(char *) "right", NULL
5547 };
5548
5549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5551 if (SWIG_arg_fail(1)) SWIG_fail;
5552 {
5553 arg2 = (int)(SWIG_As_int(obj1));
5554 if (SWIG_arg_fail(2)) SWIG_fail;
5555 }
5556 {
5557 PyThreadState* __tstate = wxPyBeginAllowThreads();
5558 (arg1)->SetRight(arg2);
5559
5560 wxPyEndAllowThreads(__tstate);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 Py_INCREF(Py_None); resultobj = Py_None;
5564 return resultobj;
5565 fail:
5566 return NULL;
5567 }
5568
5569
5570 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5571 PyObject *resultobj;
5572 wxRect *arg1 = (wxRect *) 0 ;
5573 int arg2 ;
5574 PyObject * obj0 = 0 ;
5575 PyObject * obj1 = 0 ;
5576 char *kwnames[] = {
5577 (char *) "self",(char *) "top", NULL
5578 };
5579
5580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5582 if (SWIG_arg_fail(1)) SWIG_fail;
5583 {
5584 arg2 = (int)(SWIG_As_int(obj1));
5585 if (SWIG_arg_fail(2)) SWIG_fail;
5586 }
5587 {
5588 PyThreadState* __tstate = wxPyBeginAllowThreads();
5589 (arg1)->SetTop(arg2);
5590
5591 wxPyEndAllowThreads(__tstate);
5592 if (PyErr_Occurred()) SWIG_fail;
5593 }
5594 Py_INCREF(Py_None); resultobj = Py_None;
5595 return resultobj;
5596 fail:
5597 return NULL;
5598 }
5599
5600
5601 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5602 PyObject *resultobj;
5603 wxRect *arg1 = (wxRect *) 0 ;
5604 int arg2 ;
5605 PyObject * obj0 = 0 ;
5606 PyObject * obj1 = 0 ;
5607 char *kwnames[] = {
5608 (char *) "self",(char *) "bottom", NULL
5609 };
5610
5611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5613 if (SWIG_arg_fail(1)) SWIG_fail;
5614 {
5615 arg2 = (int)(SWIG_As_int(obj1));
5616 if (SWIG_arg_fail(2)) SWIG_fail;
5617 }
5618 {
5619 PyThreadState* __tstate = wxPyBeginAllowThreads();
5620 (arg1)->SetBottom(arg2);
5621
5622 wxPyEndAllowThreads(__tstate);
5623 if (PyErr_Occurred()) SWIG_fail;
5624 }
5625 Py_INCREF(Py_None); resultobj = Py_None;
5626 return resultobj;
5627 fail:
5628 return NULL;
5629 }
5630
5631
5632 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5633 PyObject *resultobj;
5634 wxRect *arg1 = (wxRect *) 0 ;
5635 int arg2 ;
5636 int arg3 ;
5637 wxRect *result;
5638 PyObject * obj0 = 0 ;
5639 PyObject * obj1 = 0 ;
5640 PyObject * obj2 = 0 ;
5641 char *kwnames[] = {
5642 (char *) "self",(char *) "dx",(char *) "dy", NULL
5643 };
5644
5645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5647 if (SWIG_arg_fail(1)) SWIG_fail;
5648 {
5649 arg2 = (int)(SWIG_As_int(obj1));
5650 if (SWIG_arg_fail(2)) SWIG_fail;
5651 }
5652 {
5653 arg3 = (int)(SWIG_As_int(obj2));
5654 if (SWIG_arg_fail(3)) SWIG_fail;
5655 }
5656 {
5657 PyThreadState* __tstate = wxPyBeginAllowThreads();
5658 {
5659 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5660 result = (wxRect *) &_result_ref;
5661 }
5662
5663 wxPyEndAllowThreads(__tstate);
5664 if (PyErr_Occurred()) SWIG_fail;
5665 }
5666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5667 return resultobj;
5668 fail:
5669 return NULL;
5670 }
5671
5672
5673 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5674 PyObject *resultobj;
5675 wxRect *arg1 = (wxRect *) 0 ;
5676 int arg2 ;
5677 int arg3 ;
5678 wxRect *result;
5679 PyObject * obj0 = 0 ;
5680 PyObject * obj1 = 0 ;
5681 PyObject * obj2 = 0 ;
5682 char *kwnames[] = {
5683 (char *) "self",(char *) "dx",(char *) "dy", NULL
5684 };
5685
5686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5688 if (SWIG_arg_fail(1)) SWIG_fail;
5689 {
5690 arg2 = (int)(SWIG_As_int(obj1));
5691 if (SWIG_arg_fail(2)) SWIG_fail;
5692 }
5693 {
5694 arg3 = (int)(SWIG_As_int(obj2));
5695 if (SWIG_arg_fail(3)) SWIG_fail;
5696 }
5697 {
5698 PyThreadState* __tstate = wxPyBeginAllowThreads();
5699 {
5700 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5701 result = (wxRect *) &_result_ref;
5702 }
5703
5704 wxPyEndAllowThreads(__tstate);
5705 if (PyErr_Occurred()) SWIG_fail;
5706 }
5707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5708 return resultobj;
5709 fail:
5710 return NULL;
5711 }
5712
5713
5714 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5715 PyObject *resultobj;
5716 wxRect *arg1 = (wxRect *) 0 ;
5717 int arg2 ;
5718 int arg3 ;
5719 PyObject * obj0 = 0 ;
5720 PyObject * obj1 = 0 ;
5721 PyObject * obj2 = 0 ;
5722 char *kwnames[] = {
5723 (char *) "self",(char *) "dx",(char *) "dy", NULL
5724 };
5725
5726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5728 if (SWIG_arg_fail(1)) SWIG_fail;
5729 {
5730 arg2 = (int)(SWIG_As_int(obj1));
5731 if (SWIG_arg_fail(2)) SWIG_fail;
5732 }
5733 {
5734 arg3 = (int)(SWIG_As_int(obj2));
5735 if (SWIG_arg_fail(3)) SWIG_fail;
5736 }
5737 {
5738 PyThreadState* __tstate = wxPyBeginAllowThreads();
5739 (arg1)->Offset(arg2,arg3);
5740
5741 wxPyEndAllowThreads(__tstate);
5742 if (PyErr_Occurred()) SWIG_fail;
5743 }
5744 Py_INCREF(Py_None); resultobj = Py_None;
5745 return resultobj;
5746 fail:
5747 return NULL;
5748 }
5749
5750
5751 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5752 PyObject *resultobj;
5753 wxRect *arg1 = (wxRect *) 0 ;
5754 wxPoint *arg2 = 0 ;
5755 wxPoint temp2 ;
5756 PyObject * obj0 = 0 ;
5757 PyObject * obj1 = 0 ;
5758 char *kwnames[] = {
5759 (char *) "self",(char *) "pt", NULL
5760 };
5761
5762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5764 if (SWIG_arg_fail(1)) SWIG_fail;
5765 {
5766 arg2 = &temp2;
5767 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5768 }
5769 {
5770 PyThreadState* __tstate = wxPyBeginAllowThreads();
5771 (arg1)->Offset((wxPoint const &)*arg2);
5772
5773 wxPyEndAllowThreads(__tstate);
5774 if (PyErr_Occurred()) SWIG_fail;
5775 }
5776 Py_INCREF(Py_None); resultobj = Py_None;
5777 return resultobj;
5778 fail:
5779 return NULL;
5780 }
5781
5782
5783 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5784 PyObject *resultobj;
5785 wxRect *arg1 = (wxRect *) 0 ;
5786 wxRect *arg2 = 0 ;
5787 wxRect result;
5788 wxRect temp2 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 char *kwnames[] = {
5792 (char *) "self",(char *) "rect", NULL
5793 };
5794
5795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5797 if (SWIG_arg_fail(1)) SWIG_fail;
5798 {
5799 arg2 = &temp2;
5800 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5801 }
5802 {
5803 PyThreadState* __tstate = wxPyBeginAllowThreads();
5804 result = (arg1)->Intersect((wxRect const &)*arg2);
5805
5806 wxPyEndAllowThreads(__tstate);
5807 if (PyErr_Occurred()) SWIG_fail;
5808 }
5809 {
5810 wxRect * resultptr;
5811 resultptr = new wxRect((wxRect &)(result));
5812 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5813 }
5814 return resultobj;
5815 fail:
5816 return NULL;
5817 }
5818
5819
5820 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5821 PyObject *resultobj;
5822 wxRect *arg1 = (wxRect *) 0 ;
5823 wxRect *arg2 = 0 ;
5824 wxRect result;
5825 wxRect temp2 ;
5826 PyObject * obj0 = 0 ;
5827 PyObject * obj1 = 0 ;
5828 char *kwnames[] = {
5829 (char *) "self",(char *) "rect", NULL
5830 };
5831
5832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5834 if (SWIG_arg_fail(1)) SWIG_fail;
5835 {
5836 arg2 = &temp2;
5837 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5838 }
5839 {
5840 PyThreadState* __tstate = wxPyBeginAllowThreads();
5841 result = (arg1)->Union((wxRect const &)*arg2);
5842
5843 wxPyEndAllowThreads(__tstate);
5844 if (PyErr_Occurred()) SWIG_fail;
5845 }
5846 {
5847 wxRect * resultptr;
5848 resultptr = new wxRect((wxRect &)(result));
5849 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5850 }
5851 return resultobj;
5852 fail:
5853 return NULL;
5854 }
5855
5856
5857 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5858 PyObject *resultobj;
5859 wxRect *arg1 = (wxRect *) 0 ;
5860 wxRect *arg2 = 0 ;
5861 wxRect result;
5862 wxRect temp2 ;
5863 PyObject * obj0 = 0 ;
5864 PyObject * obj1 = 0 ;
5865 char *kwnames[] = {
5866 (char *) "self",(char *) "rect", NULL
5867 };
5868
5869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5871 if (SWIG_arg_fail(1)) SWIG_fail;
5872 {
5873 arg2 = &temp2;
5874 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5875 }
5876 {
5877 PyThreadState* __tstate = wxPyBeginAllowThreads();
5878 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5879
5880 wxPyEndAllowThreads(__tstate);
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 {
5884 wxRect * resultptr;
5885 resultptr = new wxRect((wxRect &)(result));
5886 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5887 }
5888 return resultobj;
5889 fail:
5890 return NULL;
5891 }
5892
5893
5894 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5895 PyObject *resultobj;
5896 wxRect *arg1 = (wxRect *) 0 ;
5897 wxRect *arg2 = 0 ;
5898 wxRect *result;
5899 wxRect temp2 ;
5900 PyObject * obj0 = 0 ;
5901 PyObject * obj1 = 0 ;
5902 char *kwnames[] = {
5903 (char *) "self",(char *) "rect", NULL
5904 };
5905
5906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5908 if (SWIG_arg_fail(1)) SWIG_fail;
5909 {
5910 arg2 = &temp2;
5911 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5912 }
5913 {
5914 PyThreadState* __tstate = wxPyBeginAllowThreads();
5915 {
5916 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5917 result = (wxRect *) &_result_ref;
5918 }
5919
5920 wxPyEndAllowThreads(__tstate);
5921 if (PyErr_Occurred()) SWIG_fail;
5922 }
5923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5924 return resultobj;
5925 fail:
5926 return NULL;
5927 }
5928
5929
5930 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5931 PyObject *resultobj;
5932 wxRect *arg1 = (wxRect *) 0 ;
5933 wxRect *arg2 = 0 ;
5934 bool result;
5935 wxRect temp2 ;
5936 PyObject * obj0 = 0 ;
5937 PyObject * obj1 = 0 ;
5938 char *kwnames[] = {
5939 (char *) "self",(char *) "rect", NULL
5940 };
5941
5942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5944 if (SWIG_arg_fail(1)) SWIG_fail;
5945 {
5946 arg2 = &temp2;
5947 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5948 }
5949 {
5950 PyThreadState* __tstate = wxPyBeginAllowThreads();
5951 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5952
5953 wxPyEndAllowThreads(__tstate);
5954 if (PyErr_Occurred()) SWIG_fail;
5955 }
5956 {
5957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5958 }
5959 return resultobj;
5960 fail:
5961 return NULL;
5962 }
5963
5964
5965 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5966 PyObject *resultobj;
5967 wxRect *arg1 = (wxRect *) 0 ;
5968 wxRect *arg2 = 0 ;
5969 bool result;
5970 wxRect temp2 ;
5971 PyObject * obj0 = 0 ;
5972 PyObject * obj1 = 0 ;
5973 char *kwnames[] = {
5974 (char *) "self",(char *) "rect", NULL
5975 };
5976
5977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5979 if (SWIG_arg_fail(1)) SWIG_fail;
5980 {
5981 arg2 = &temp2;
5982 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5983 }
5984 {
5985 PyThreadState* __tstate = wxPyBeginAllowThreads();
5986 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5987
5988 wxPyEndAllowThreads(__tstate);
5989 if (PyErr_Occurred()) SWIG_fail;
5990 }
5991 {
5992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5993 }
5994 return resultobj;
5995 fail:
5996 return NULL;
5997 }
5998
5999
6000 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj;
6002 wxRect *arg1 = (wxRect *) 0 ;
6003 int arg2 ;
6004 int arg3 ;
6005 bool result;
6006 PyObject * obj0 = 0 ;
6007 PyObject * obj1 = 0 ;
6008 PyObject * obj2 = 0 ;
6009 char *kwnames[] = {
6010 (char *) "self",(char *) "x",(char *) "y", NULL
6011 };
6012
6013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6015 if (SWIG_arg_fail(1)) SWIG_fail;
6016 {
6017 arg2 = (int)(SWIG_As_int(obj1));
6018 if (SWIG_arg_fail(2)) SWIG_fail;
6019 }
6020 {
6021 arg3 = (int)(SWIG_As_int(obj2));
6022 if (SWIG_arg_fail(3)) SWIG_fail;
6023 }
6024 {
6025 PyThreadState* __tstate = wxPyBeginAllowThreads();
6026 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6027
6028 wxPyEndAllowThreads(__tstate);
6029 if (PyErr_Occurred()) SWIG_fail;
6030 }
6031 {
6032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6033 }
6034 return resultobj;
6035 fail:
6036 return NULL;
6037 }
6038
6039
6040 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6041 PyObject *resultobj;
6042 wxRect *arg1 = (wxRect *) 0 ;
6043 wxPoint *arg2 = 0 ;
6044 bool result;
6045 wxPoint temp2 ;
6046 PyObject * obj0 = 0 ;
6047 PyObject * obj1 = 0 ;
6048 char *kwnames[] = {
6049 (char *) "self",(char *) "pt", NULL
6050 };
6051
6052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6054 if (SWIG_arg_fail(1)) SWIG_fail;
6055 {
6056 arg2 = &temp2;
6057 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6058 }
6059 {
6060 PyThreadState* __tstate = wxPyBeginAllowThreads();
6061 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6062
6063 wxPyEndAllowThreads(__tstate);
6064 if (PyErr_Occurred()) SWIG_fail;
6065 }
6066 {
6067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6068 }
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj;
6077 wxRect *arg1 = (wxRect *) 0 ;
6078 wxRect *arg2 = 0 ;
6079 bool result;
6080 wxRect temp2 ;
6081 PyObject * obj0 = 0 ;
6082 PyObject * obj1 = 0 ;
6083 char *kwnames[] = {
6084 (char *) "self",(char *) "rect", NULL
6085 };
6086
6087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6089 if (SWIG_arg_fail(1)) SWIG_fail;
6090 {
6091 arg2 = &temp2;
6092 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6093 }
6094 {
6095 PyThreadState* __tstate = wxPyBeginAllowThreads();
6096 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6097
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 {
6102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6103 }
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj;
6112 wxRect *arg1 = (wxRect *) 0 ;
6113 int arg2 ;
6114 PyObject * obj0 = 0 ;
6115 PyObject * obj1 = 0 ;
6116 char *kwnames[] = {
6117 (char *) "self",(char *) "x", NULL
6118 };
6119
6120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6122 if (SWIG_arg_fail(1)) SWIG_fail;
6123 {
6124 arg2 = (int)(SWIG_As_int(obj1));
6125 if (SWIG_arg_fail(2)) SWIG_fail;
6126 }
6127 if (arg1) (arg1)->x = arg2;
6128
6129 Py_INCREF(Py_None); resultobj = Py_None;
6130 return resultobj;
6131 fail:
6132 return NULL;
6133 }
6134
6135
6136 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6137 PyObject *resultobj;
6138 wxRect *arg1 = (wxRect *) 0 ;
6139 int result;
6140 PyObject * obj0 = 0 ;
6141 char *kwnames[] = {
6142 (char *) "self", NULL
6143 };
6144
6145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6147 if (SWIG_arg_fail(1)) SWIG_fail;
6148 result = (int) ((arg1)->x);
6149
6150 {
6151 resultobj = SWIG_From_int((int)(result));
6152 }
6153 return resultobj;
6154 fail:
6155 return NULL;
6156 }
6157
6158
6159 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6160 PyObject *resultobj;
6161 wxRect *arg1 = (wxRect *) 0 ;
6162 int arg2 ;
6163 PyObject * obj0 = 0 ;
6164 PyObject * obj1 = 0 ;
6165 char *kwnames[] = {
6166 (char *) "self",(char *) "y", NULL
6167 };
6168
6169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6171 if (SWIG_arg_fail(1)) SWIG_fail;
6172 {
6173 arg2 = (int)(SWIG_As_int(obj1));
6174 if (SWIG_arg_fail(2)) SWIG_fail;
6175 }
6176 if (arg1) (arg1)->y = arg2;
6177
6178 Py_INCREF(Py_None); resultobj = Py_None;
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj;
6187 wxRect *arg1 = (wxRect *) 0 ;
6188 int result;
6189 PyObject * obj0 = 0 ;
6190 char *kwnames[] = {
6191 (char *) "self", NULL
6192 };
6193
6194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6196 if (SWIG_arg_fail(1)) SWIG_fail;
6197 result = (int) ((arg1)->y);
6198
6199 {
6200 resultobj = SWIG_From_int((int)(result));
6201 }
6202 return resultobj;
6203 fail:
6204 return NULL;
6205 }
6206
6207
6208 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6209 PyObject *resultobj;
6210 wxRect *arg1 = (wxRect *) 0 ;
6211 int arg2 ;
6212 PyObject * obj0 = 0 ;
6213 PyObject * obj1 = 0 ;
6214 char *kwnames[] = {
6215 (char *) "self",(char *) "width", NULL
6216 };
6217
6218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6220 if (SWIG_arg_fail(1)) SWIG_fail;
6221 {
6222 arg2 = (int)(SWIG_As_int(obj1));
6223 if (SWIG_arg_fail(2)) SWIG_fail;
6224 }
6225 if (arg1) (arg1)->width = arg2;
6226
6227 Py_INCREF(Py_None); resultobj = Py_None;
6228 return resultobj;
6229 fail:
6230 return NULL;
6231 }
6232
6233
6234 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6235 PyObject *resultobj;
6236 wxRect *arg1 = (wxRect *) 0 ;
6237 int result;
6238 PyObject * obj0 = 0 ;
6239 char *kwnames[] = {
6240 (char *) "self", NULL
6241 };
6242
6243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6245 if (SWIG_arg_fail(1)) SWIG_fail;
6246 result = (int) ((arg1)->width);
6247
6248 {
6249 resultobj = SWIG_From_int((int)(result));
6250 }
6251 return resultobj;
6252 fail:
6253 return NULL;
6254 }
6255
6256
6257 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6258 PyObject *resultobj;
6259 wxRect *arg1 = (wxRect *) 0 ;
6260 int arg2 ;
6261 PyObject * obj0 = 0 ;
6262 PyObject * obj1 = 0 ;
6263 char *kwnames[] = {
6264 (char *) "self",(char *) "height", NULL
6265 };
6266
6267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6269 if (SWIG_arg_fail(1)) SWIG_fail;
6270 {
6271 arg2 = (int)(SWIG_As_int(obj1));
6272 if (SWIG_arg_fail(2)) SWIG_fail;
6273 }
6274 if (arg1) (arg1)->height = arg2;
6275
6276 Py_INCREF(Py_None); resultobj = Py_None;
6277 return resultobj;
6278 fail:
6279 return NULL;
6280 }
6281
6282
6283 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6284 PyObject *resultobj;
6285 wxRect *arg1 = (wxRect *) 0 ;
6286 int result;
6287 PyObject * obj0 = 0 ;
6288 char *kwnames[] = {
6289 (char *) "self", NULL
6290 };
6291
6292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6294 if (SWIG_arg_fail(1)) SWIG_fail;
6295 result = (int) ((arg1)->height);
6296
6297 {
6298 resultobj = SWIG_From_int((int)(result));
6299 }
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj;
6308 wxRect *arg1 = (wxRect *) 0 ;
6309 int arg2 = (int) 0 ;
6310 int arg3 = (int) 0 ;
6311 int arg4 = (int) 0 ;
6312 int arg5 = (int) 0 ;
6313 PyObject * obj0 = 0 ;
6314 PyObject * obj1 = 0 ;
6315 PyObject * obj2 = 0 ;
6316 PyObject * obj3 = 0 ;
6317 PyObject * obj4 = 0 ;
6318 char *kwnames[] = {
6319 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6320 };
6321
6322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6324 if (SWIG_arg_fail(1)) SWIG_fail;
6325 if (obj1) {
6326 {
6327 arg2 = (int)(SWIG_As_int(obj1));
6328 if (SWIG_arg_fail(2)) SWIG_fail;
6329 }
6330 }
6331 if (obj2) {
6332 {
6333 arg3 = (int)(SWIG_As_int(obj2));
6334 if (SWIG_arg_fail(3)) SWIG_fail;
6335 }
6336 }
6337 if (obj3) {
6338 {
6339 arg4 = (int)(SWIG_As_int(obj3));
6340 if (SWIG_arg_fail(4)) SWIG_fail;
6341 }
6342 }
6343 if (obj4) {
6344 {
6345 arg5 = (int)(SWIG_As_int(obj4));
6346 if (SWIG_arg_fail(5)) SWIG_fail;
6347 }
6348 }
6349 {
6350 PyThreadState* __tstate = wxPyBeginAllowThreads();
6351 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6352
6353 wxPyEndAllowThreads(__tstate);
6354 if (PyErr_Occurred()) SWIG_fail;
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_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6364 PyObject *resultobj;
6365 wxRect *arg1 = (wxRect *) 0 ;
6366 PyObject *result;
6367 PyObject * obj0 = 0 ;
6368 char *kwnames[] = {
6369 (char *) "self", NULL
6370 };
6371
6372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_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 {
6376 PyThreadState* __tstate = wxPyBeginAllowThreads();
6377 result = (PyObject *)wxRect_Get(arg1);
6378
6379 wxPyEndAllowThreads(__tstate);
6380 if (PyErr_Occurred()) SWIG_fail;
6381 }
6382 resultobj = result;
6383 return resultobj;
6384 fail:
6385 return NULL;
6386 }
6387
6388
6389 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6390 PyObject *obj;
6391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6392 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6393 Py_INCREF(obj);
6394 return Py_BuildValue((char *)"");
6395 }
6396 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6397 PyObject *resultobj;
6398 wxRect *arg1 = (wxRect *) 0 ;
6399 wxRect *arg2 = (wxRect *) 0 ;
6400 PyObject *result;
6401 PyObject * obj0 = 0 ;
6402 PyObject * obj1 = 0 ;
6403 char *kwnames[] = {
6404 (char *) "r1",(char *) "r2", NULL
6405 };
6406
6407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6409 if (SWIG_arg_fail(1)) SWIG_fail;
6410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6411 if (SWIG_arg_fail(2)) SWIG_fail;
6412 {
6413 if (!wxPyCheckForApp()) SWIG_fail;
6414 PyThreadState* __tstate = wxPyBeginAllowThreads();
6415 result = (PyObject *)wxIntersectRect(arg1,arg2);
6416
6417 wxPyEndAllowThreads(__tstate);
6418 if (PyErr_Occurred()) SWIG_fail;
6419 }
6420 resultobj = result;
6421 return resultobj;
6422 fail:
6423 return NULL;
6424 }
6425
6426
6427 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6428 PyObject *resultobj;
6429 double arg1 = (double) 0.0 ;
6430 double arg2 = (double) 0.0 ;
6431 wxPoint2D *result;
6432 PyObject * obj0 = 0 ;
6433 PyObject * obj1 = 0 ;
6434 char *kwnames[] = {
6435 (char *) "x",(char *) "y", NULL
6436 };
6437
6438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6439 if (obj0) {
6440 {
6441 arg1 = (double)(SWIG_As_double(obj0));
6442 if (SWIG_arg_fail(1)) SWIG_fail;
6443 }
6444 }
6445 if (obj1) {
6446 {
6447 arg2 = (double)(SWIG_As_double(obj1));
6448 if (SWIG_arg_fail(2)) SWIG_fail;
6449 }
6450 }
6451 {
6452 PyThreadState* __tstate = wxPyBeginAllowThreads();
6453 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6454
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj;
6467 wxPoint2D *arg1 = 0 ;
6468 wxPoint2D *result;
6469 wxPoint2D temp1 ;
6470 PyObject * obj0 = 0 ;
6471 char *kwnames[] = {
6472 (char *) "pt", NULL
6473 };
6474
6475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6476 {
6477 arg1 = &temp1;
6478 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6479 }
6480 {
6481 PyThreadState* __tstate = wxPyBeginAllowThreads();
6482 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6483
6484 wxPyEndAllowThreads(__tstate);
6485 if (PyErr_Occurred()) SWIG_fail;
6486 }
6487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6488 return resultobj;
6489 fail:
6490 return NULL;
6491 }
6492
6493
6494 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6495 PyObject *resultobj;
6496 wxPoint *arg1 = 0 ;
6497 wxPoint2D *result;
6498 wxPoint temp1 ;
6499 PyObject * obj0 = 0 ;
6500 char *kwnames[] = {
6501 (char *) "pt", NULL
6502 };
6503
6504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6505 {
6506 arg1 = &temp1;
6507 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6508 }
6509 {
6510 PyThreadState* __tstate = wxPyBeginAllowThreads();
6511 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6512
6513 wxPyEndAllowThreads(__tstate);
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6517 return resultobj;
6518 fail:
6519 return NULL;
6520 }
6521
6522
6523 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6524 PyObject *resultobj;
6525 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6526 int *arg2 = (int *) 0 ;
6527 int *arg3 = (int *) 0 ;
6528 int temp2 ;
6529 int res2 = 0 ;
6530 int temp3 ;
6531 int res3 = 0 ;
6532 PyObject * obj0 = 0 ;
6533 char *kwnames[] = {
6534 (char *) "self", NULL
6535 };
6536
6537 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6538 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6541 if (SWIG_arg_fail(1)) SWIG_fail;
6542 {
6543 PyThreadState* __tstate = wxPyBeginAllowThreads();
6544 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6545
6546 wxPyEndAllowThreads(__tstate);
6547 if (PyErr_Occurred()) SWIG_fail;
6548 }
6549 Py_INCREF(Py_None); resultobj = Py_None;
6550 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6551 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6552 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6553 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6554 return resultobj;
6555 fail:
6556 return NULL;
6557 }
6558
6559
6560 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6561 PyObject *resultobj;
6562 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6563 int *arg2 = (int *) 0 ;
6564 int *arg3 = (int *) 0 ;
6565 int temp2 ;
6566 int res2 = 0 ;
6567 int temp3 ;
6568 int res3 = 0 ;
6569 PyObject * obj0 = 0 ;
6570 char *kwnames[] = {
6571 (char *) "self", NULL
6572 };
6573
6574 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6575 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6578 if (SWIG_arg_fail(1)) SWIG_fail;
6579 {
6580 PyThreadState* __tstate = wxPyBeginAllowThreads();
6581 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6582
6583 wxPyEndAllowThreads(__tstate);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 Py_INCREF(Py_None); resultobj = Py_None;
6587 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6588 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6589 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6590 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6591 return resultobj;
6592 fail:
6593 return NULL;
6594 }
6595
6596
6597 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6598 PyObject *resultobj;
6599 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6600 double result;
6601 PyObject * obj0 = 0 ;
6602 char *kwnames[] = {
6603 (char *) "self", NULL
6604 };
6605
6606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6608 if (SWIG_arg_fail(1)) SWIG_fail;
6609 {
6610 PyThreadState* __tstate = wxPyBeginAllowThreads();
6611 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6612
6613 wxPyEndAllowThreads(__tstate);
6614 if (PyErr_Occurred()) SWIG_fail;
6615 }
6616 {
6617 resultobj = SWIG_From_double((double)(result));
6618 }
6619 return resultobj;
6620 fail:
6621 return NULL;
6622 }
6623
6624
6625 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6626 PyObject *resultobj;
6627 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6628 double result;
6629 PyObject * obj0 = 0 ;
6630 char *kwnames[] = {
6631 (char *) "self", NULL
6632 };
6633
6634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6636 if (SWIG_arg_fail(1)) SWIG_fail;
6637 {
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6640
6641 wxPyEndAllowThreads(__tstate);
6642 if (PyErr_Occurred()) SWIG_fail;
6643 }
6644 {
6645 resultobj = SWIG_From_double((double)(result));
6646 }
6647 return resultobj;
6648 fail:
6649 return NULL;
6650 }
6651
6652
6653 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6654 PyObject *resultobj;
6655 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6656 double arg2 ;
6657 PyObject * obj0 = 0 ;
6658 PyObject * obj1 = 0 ;
6659 char *kwnames[] = {
6660 (char *) "self",(char *) "length", NULL
6661 };
6662
6663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6665 if (SWIG_arg_fail(1)) SWIG_fail;
6666 {
6667 arg2 = (double)(SWIG_As_double(obj1));
6668 if (SWIG_arg_fail(2)) SWIG_fail;
6669 }
6670 {
6671 PyThreadState* __tstate = wxPyBeginAllowThreads();
6672 (arg1)->SetVectorLength(arg2);
6673
6674 wxPyEndAllowThreads(__tstate);
6675 if (PyErr_Occurred()) SWIG_fail;
6676 }
6677 Py_INCREF(Py_None); resultobj = Py_None;
6678 return resultobj;
6679 fail:
6680 return NULL;
6681 }
6682
6683
6684 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6685 PyObject *resultobj;
6686 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6687 double arg2 ;
6688 PyObject * obj0 = 0 ;
6689 PyObject * obj1 = 0 ;
6690 char *kwnames[] = {
6691 (char *) "self",(char *) "degrees", NULL
6692 };
6693
6694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6696 if (SWIG_arg_fail(1)) SWIG_fail;
6697 {
6698 arg2 = (double)(SWIG_As_double(obj1));
6699 if (SWIG_arg_fail(2)) SWIG_fail;
6700 }
6701 {
6702 PyThreadState* __tstate = wxPyBeginAllowThreads();
6703 (arg1)->SetVectorAngle(arg2);
6704
6705 wxPyEndAllowThreads(__tstate);
6706 if (PyErr_Occurred()) SWIG_fail;
6707 }
6708 Py_INCREF(Py_None); resultobj = Py_None;
6709 return resultobj;
6710 fail:
6711 return NULL;
6712 }
6713
6714
6715 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6716 PyObject *resultobj;
6717 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6718 wxPoint2D *arg2 = 0 ;
6719 double result;
6720 wxPoint2D temp2 ;
6721 PyObject * obj0 = 0 ;
6722 PyObject * obj1 = 0 ;
6723 char *kwnames[] = {
6724 (char *) "self",(char *) "pt", NULL
6725 };
6726
6727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6729 if (SWIG_arg_fail(1)) SWIG_fail;
6730 {
6731 arg2 = &temp2;
6732 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6733 }
6734 {
6735 PyThreadState* __tstate = wxPyBeginAllowThreads();
6736 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6737
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 {
6742 resultobj = SWIG_From_double((double)(result));
6743 }
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6751 PyObject *resultobj;
6752 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6753 wxPoint2D *arg2 = 0 ;
6754 double result;
6755 wxPoint2D temp2 ;
6756 PyObject * obj0 = 0 ;
6757 PyObject * obj1 = 0 ;
6758 char *kwnames[] = {
6759 (char *) "self",(char *) "pt", NULL
6760 };
6761
6762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6764 if (SWIG_arg_fail(1)) SWIG_fail;
6765 {
6766 arg2 = &temp2;
6767 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6768 }
6769 {
6770 PyThreadState* __tstate = wxPyBeginAllowThreads();
6771 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6772
6773 wxPyEndAllowThreads(__tstate);
6774 if (PyErr_Occurred()) SWIG_fail;
6775 }
6776 {
6777 resultobj = SWIG_From_double((double)(result));
6778 }
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6786 PyObject *resultobj;
6787 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6788 wxPoint2D *arg2 = 0 ;
6789 double result;
6790 wxPoint2D temp2 ;
6791 PyObject * obj0 = 0 ;
6792 PyObject * obj1 = 0 ;
6793 char *kwnames[] = {
6794 (char *) "self",(char *) "vec", NULL
6795 };
6796
6797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6799 if (SWIG_arg_fail(1)) SWIG_fail;
6800 {
6801 arg2 = &temp2;
6802 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6803 }
6804 {
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6807
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 {
6812 resultobj = SWIG_From_double((double)(result));
6813 }
6814 return resultobj;
6815 fail:
6816 return NULL;
6817 }
6818
6819
6820 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6821 PyObject *resultobj;
6822 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6823 wxPoint2D *arg2 = 0 ;
6824 double result;
6825 wxPoint2D temp2 ;
6826 PyObject * obj0 = 0 ;
6827 PyObject * obj1 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self",(char *) "vec", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 arg2 = &temp2;
6837 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6838 }
6839 {
6840 PyThreadState* __tstate = wxPyBeginAllowThreads();
6841 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6842
6843 wxPyEndAllowThreads(__tstate);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 {
6847 resultobj = SWIG_From_double((double)(result));
6848 }
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6856 PyObject *resultobj;
6857 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6858 wxPoint2D result;
6859 PyObject * obj0 = 0 ;
6860 char *kwnames[] = {
6861 (char *) "self", NULL
6862 };
6863
6864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6866 if (SWIG_arg_fail(1)) SWIG_fail;
6867 {
6868 PyThreadState* __tstate = wxPyBeginAllowThreads();
6869 result = (arg1)->operator -();
6870
6871 wxPyEndAllowThreads(__tstate);
6872 if (PyErr_Occurred()) SWIG_fail;
6873 }
6874 {
6875 wxPoint2D * resultptr;
6876 resultptr = new wxPoint2D((wxPoint2D &)(result));
6877 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6878 }
6879 return resultobj;
6880 fail:
6881 return NULL;
6882 }
6883
6884
6885 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6886 PyObject *resultobj;
6887 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6888 wxPoint2D *arg2 = 0 ;
6889 wxPoint2D *result;
6890 wxPoint2D temp2 ;
6891 PyObject * obj0 = 0 ;
6892 PyObject * obj1 = 0 ;
6893 char *kwnames[] = {
6894 (char *) "self",(char *) "pt", NULL
6895 };
6896
6897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6899 if (SWIG_arg_fail(1)) SWIG_fail;
6900 {
6901 arg2 = &temp2;
6902 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6903 }
6904 {
6905 PyThreadState* __tstate = wxPyBeginAllowThreads();
6906 {
6907 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6908 result = (wxPoint2D *) &_result_ref;
6909 }
6910
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6922 PyObject *resultobj;
6923 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6924 wxPoint2D *arg2 = 0 ;
6925 wxPoint2D *result;
6926 wxPoint2D temp2 ;
6927 PyObject * obj0 = 0 ;
6928 PyObject * obj1 = 0 ;
6929 char *kwnames[] = {
6930 (char *) "self",(char *) "pt", NULL
6931 };
6932
6933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6935 if (SWIG_arg_fail(1)) SWIG_fail;
6936 {
6937 arg2 = &temp2;
6938 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6939 }
6940 {
6941 PyThreadState* __tstate = wxPyBeginAllowThreads();
6942 {
6943 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6944 result = (wxPoint2D *) &_result_ref;
6945 }
6946
6947 wxPyEndAllowThreads(__tstate);
6948 if (PyErr_Occurred()) SWIG_fail;
6949 }
6950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6951 return resultobj;
6952 fail:
6953 return NULL;
6954 }
6955
6956
6957 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6958 PyObject *resultobj;
6959 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6960 wxPoint2D *arg2 = 0 ;
6961 wxPoint2D *result;
6962 wxPoint2D temp2 ;
6963 PyObject * obj0 = 0 ;
6964 PyObject * obj1 = 0 ;
6965 char *kwnames[] = {
6966 (char *) "self",(char *) "pt", NULL
6967 };
6968
6969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6971 if (SWIG_arg_fail(1)) SWIG_fail;
6972 {
6973 arg2 = &temp2;
6974 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6975 }
6976 {
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 {
6979 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6980 result = (wxPoint2D *) &_result_ref;
6981 }
6982
6983 wxPyEndAllowThreads(__tstate);
6984 if (PyErr_Occurred()) SWIG_fail;
6985 }
6986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6987 return resultobj;
6988 fail:
6989 return NULL;
6990 }
6991
6992
6993 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
6994 PyObject *resultobj;
6995 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6996 wxPoint2D *arg2 = 0 ;
6997 wxPoint2D *result;
6998 wxPoint2D temp2 ;
6999 PyObject * obj0 = 0 ;
7000 PyObject * obj1 = 0 ;
7001 char *kwnames[] = {
7002 (char *) "self",(char *) "pt", NULL
7003 };
7004
7005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7007 if (SWIG_arg_fail(1)) SWIG_fail;
7008 {
7009 arg2 = &temp2;
7010 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7011 }
7012 {
7013 PyThreadState* __tstate = wxPyBeginAllowThreads();
7014 {
7015 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7016 result = (wxPoint2D *) &_result_ref;
7017 }
7018
7019 wxPyEndAllowThreads(__tstate);
7020 if (PyErr_Occurred()) SWIG_fail;
7021 }
7022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7023 return resultobj;
7024 fail:
7025 return NULL;
7026 }
7027
7028
7029 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7030 PyObject *resultobj;
7031 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7032 wxPoint2D *arg2 = 0 ;
7033 bool result;
7034 wxPoint2D temp2 ;
7035 PyObject * obj0 = 0 ;
7036 PyObject * obj1 = 0 ;
7037 char *kwnames[] = {
7038 (char *) "self",(char *) "pt", NULL
7039 };
7040
7041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7043 if (SWIG_arg_fail(1)) SWIG_fail;
7044 {
7045 arg2 = &temp2;
7046 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7047 }
7048 {
7049 PyThreadState* __tstate = wxPyBeginAllowThreads();
7050 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7051
7052 wxPyEndAllowThreads(__tstate);
7053 if (PyErr_Occurred()) SWIG_fail;
7054 }
7055 {
7056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7057 }
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj;
7066 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7067 wxPoint2D *arg2 = 0 ;
7068 bool result;
7069 wxPoint2D temp2 ;
7070 PyObject * obj0 = 0 ;
7071 PyObject * obj1 = 0 ;
7072 char *kwnames[] = {
7073 (char *) "self",(char *) "pt", NULL
7074 };
7075
7076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7078 if (SWIG_arg_fail(1)) SWIG_fail;
7079 {
7080 arg2 = &temp2;
7081 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7082 }
7083 {
7084 PyThreadState* __tstate = wxPyBeginAllowThreads();
7085 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7086
7087 wxPyEndAllowThreads(__tstate);
7088 if (PyErr_Occurred()) SWIG_fail;
7089 }
7090 {
7091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7092 }
7093 return resultobj;
7094 fail:
7095 return NULL;
7096 }
7097
7098
7099 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7100 PyObject *resultobj;
7101 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7102 double arg2 ;
7103 PyObject * obj0 = 0 ;
7104 PyObject * obj1 = 0 ;
7105 char *kwnames[] = {
7106 (char *) "self",(char *) "m_x", NULL
7107 };
7108
7109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7111 if (SWIG_arg_fail(1)) SWIG_fail;
7112 {
7113 arg2 = (double)(SWIG_As_double(obj1));
7114 if (SWIG_arg_fail(2)) SWIG_fail;
7115 }
7116 if (arg1) (arg1)->m_x = arg2;
7117
7118 Py_INCREF(Py_None); resultobj = Py_None;
7119 return resultobj;
7120 fail:
7121 return NULL;
7122 }
7123
7124
7125 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7126 PyObject *resultobj;
7127 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7128 double result;
7129 PyObject * obj0 = 0 ;
7130 char *kwnames[] = {
7131 (char *) "self", NULL
7132 };
7133
7134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7136 if (SWIG_arg_fail(1)) SWIG_fail;
7137 result = (double) ((arg1)->m_x);
7138
7139 {
7140 resultobj = SWIG_From_double((double)(result));
7141 }
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj;
7150 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7151 double arg2 ;
7152 PyObject * obj0 = 0 ;
7153 PyObject * obj1 = 0 ;
7154 char *kwnames[] = {
7155 (char *) "self",(char *) "m_y", NULL
7156 };
7157
7158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7160 if (SWIG_arg_fail(1)) SWIG_fail;
7161 {
7162 arg2 = (double)(SWIG_As_double(obj1));
7163 if (SWIG_arg_fail(2)) SWIG_fail;
7164 }
7165 if (arg1) (arg1)->m_y = arg2;
7166
7167 Py_INCREF(Py_None); resultobj = Py_None;
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj;
7176 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7177 double result;
7178 PyObject * obj0 = 0 ;
7179 char *kwnames[] = {
7180 (char *) "self", NULL
7181 };
7182
7183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7185 if (SWIG_arg_fail(1)) SWIG_fail;
7186 result = (double) ((arg1)->m_y);
7187
7188 {
7189 resultobj = SWIG_From_double((double)(result));
7190 }
7191 return resultobj;
7192 fail:
7193 return NULL;
7194 }
7195
7196
7197 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7198 PyObject *resultobj;
7199 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7200 double arg2 = (double) 0 ;
7201 double arg3 = (double) 0 ;
7202 PyObject * obj0 = 0 ;
7203 PyObject * obj1 = 0 ;
7204 PyObject * obj2 = 0 ;
7205 char *kwnames[] = {
7206 (char *) "self",(char *) "x",(char *) "y", NULL
7207 };
7208
7209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7211 if (SWIG_arg_fail(1)) SWIG_fail;
7212 if (obj1) {
7213 {
7214 arg2 = (double)(SWIG_As_double(obj1));
7215 if (SWIG_arg_fail(2)) SWIG_fail;
7216 }
7217 }
7218 if (obj2) {
7219 {
7220 arg3 = (double)(SWIG_As_double(obj2));
7221 if (SWIG_arg_fail(3)) SWIG_fail;
7222 }
7223 }
7224 {
7225 PyThreadState* __tstate = wxPyBeginAllowThreads();
7226 wxPoint2D_Set(arg1,arg2,arg3);
7227
7228 wxPyEndAllowThreads(__tstate);
7229 if (PyErr_Occurred()) SWIG_fail;
7230 }
7231 Py_INCREF(Py_None); resultobj = Py_None;
7232 return resultobj;
7233 fail:
7234 return NULL;
7235 }
7236
7237
7238 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7239 PyObject *resultobj;
7240 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7241 PyObject *result;
7242 PyObject * obj0 = 0 ;
7243 char *kwnames[] = {
7244 (char *) "self", NULL
7245 };
7246
7247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7249 if (SWIG_arg_fail(1)) SWIG_fail;
7250 {
7251 PyThreadState* __tstate = wxPyBeginAllowThreads();
7252 result = (PyObject *)wxPoint2D_Get(arg1);
7253
7254 wxPyEndAllowThreads(__tstate);
7255 if (PyErr_Occurred()) SWIG_fail;
7256 }
7257 resultobj = result;
7258 return resultobj;
7259 fail:
7260 return NULL;
7261 }
7262
7263
7264 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7265 PyObject *obj;
7266 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7267 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7268 Py_INCREF(obj);
7269 return Py_BuildValue((char *)"");
7270 }
7271 static int _wrap_DefaultPosition_set(PyObject *) {
7272 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7273 return 1;
7274 }
7275
7276
7277 static PyObject *_wrap_DefaultPosition_get(void) {
7278 PyObject *pyobj;
7279
7280 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7281 return pyobj;
7282 }
7283
7284
7285 static int _wrap_DefaultSize_set(PyObject *) {
7286 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7287 return 1;
7288 }
7289
7290
7291 static PyObject *_wrap_DefaultSize_get(void) {
7292 PyObject *pyobj;
7293
7294 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7295 return pyobj;
7296 }
7297
7298
7299 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7300 PyObject *resultobj;
7301 PyObject *arg1 = (PyObject *) 0 ;
7302 wxPyInputStream *result;
7303 PyObject * obj0 = 0 ;
7304 char *kwnames[] = {
7305 (char *) "p", NULL
7306 };
7307
7308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7309 arg1 = obj0;
7310 {
7311 PyThreadState* __tstate = wxPyBeginAllowThreads();
7312 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7313
7314 wxPyEndAllowThreads(__tstate);
7315 if (PyErr_Occurred()) SWIG_fail;
7316 }
7317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7318 return resultobj;
7319 fail:
7320 return NULL;
7321 }
7322
7323
7324 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7325 PyObject *resultobj;
7326 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7327 PyObject * obj0 = 0 ;
7328 char *kwnames[] = {
7329 (char *) "self", NULL
7330 };
7331
7332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7334 if (SWIG_arg_fail(1)) SWIG_fail;
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 delete arg1;
7338
7339 wxPyEndAllowThreads(__tstate);
7340 if (PyErr_Occurred()) SWIG_fail;
7341 }
7342 Py_INCREF(Py_None); resultobj = Py_None;
7343 return resultobj;
7344 fail:
7345 return NULL;
7346 }
7347
7348
7349 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7350 PyObject *resultobj;
7351 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7352 PyObject * obj0 = 0 ;
7353 char *kwnames[] = {
7354 (char *) "self", NULL
7355 };
7356
7357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7359 if (SWIG_arg_fail(1)) SWIG_fail;
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 (arg1)->close();
7363
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 Py_INCREF(Py_None); resultobj = Py_None;
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj;
7376 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7377 PyObject * obj0 = 0 ;
7378 char *kwnames[] = {
7379 (char *) "self", NULL
7380 };
7381
7382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7384 if (SWIG_arg_fail(1)) SWIG_fail;
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 (arg1)->flush();
7388
7389 wxPyEndAllowThreads(__tstate);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 Py_INCREF(Py_None); resultobj = Py_None;
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj;
7401 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7402 bool result;
7403 PyObject * obj0 = 0 ;
7404 char *kwnames[] = {
7405 (char *) "self", NULL
7406 };
7407
7408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7410 if (SWIG_arg_fail(1)) SWIG_fail;
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 result = (bool)(arg1)->eof();
7414
7415 wxPyEndAllowThreads(__tstate);
7416 if (PyErr_Occurred()) SWIG_fail;
7417 }
7418 {
7419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7420 }
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7428 PyObject *resultobj;
7429 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7430 int arg2 = (int) -1 ;
7431 PyObject *result;
7432 PyObject * obj0 = 0 ;
7433 PyObject * obj1 = 0 ;
7434 char *kwnames[] = {
7435 (char *) "self",(char *) "size", NULL
7436 };
7437
7438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7440 if (SWIG_arg_fail(1)) SWIG_fail;
7441 if (obj1) {
7442 {
7443 arg2 = (int)(SWIG_As_int(obj1));
7444 if (SWIG_arg_fail(2)) SWIG_fail;
7445 }
7446 }
7447 {
7448 PyThreadState* __tstate = wxPyBeginAllowThreads();
7449 result = (PyObject *)(arg1)->read(arg2);
7450
7451 wxPyEndAllowThreads(__tstate);
7452 if (PyErr_Occurred()) SWIG_fail;
7453 }
7454 resultobj = result;
7455 return resultobj;
7456 fail:
7457 return NULL;
7458 }
7459
7460
7461 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7462 PyObject *resultobj;
7463 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7464 int arg2 = (int) -1 ;
7465 PyObject *result;
7466 PyObject * obj0 = 0 ;
7467 PyObject * obj1 = 0 ;
7468 char *kwnames[] = {
7469 (char *) "self",(char *) "size", NULL
7470 };
7471
7472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7474 if (SWIG_arg_fail(1)) SWIG_fail;
7475 if (obj1) {
7476 {
7477 arg2 = (int)(SWIG_As_int(obj1));
7478 if (SWIG_arg_fail(2)) SWIG_fail;
7479 }
7480 }
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 result = (PyObject *)(arg1)->readline(arg2);
7484
7485 wxPyEndAllowThreads(__tstate);
7486 if (PyErr_Occurred()) SWIG_fail;
7487 }
7488 resultobj = result;
7489 return resultobj;
7490 fail:
7491 return NULL;
7492 }
7493
7494
7495 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7496 PyObject *resultobj;
7497 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7498 int arg2 = (int) -1 ;
7499 PyObject *result;
7500 PyObject * obj0 = 0 ;
7501 PyObject * obj1 = 0 ;
7502 char *kwnames[] = {
7503 (char *) "self",(char *) "sizehint", NULL
7504 };
7505
7506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7508 if (SWIG_arg_fail(1)) SWIG_fail;
7509 if (obj1) {
7510 {
7511 arg2 = (int)(SWIG_As_int(obj1));
7512 if (SWIG_arg_fail(2)) SWIG_fail;
7513 }
7514 }
7515 {
7516 PyThreadState* __tstate = wxPyBeginAllowThreads();
7517 result = (PyObject *)(arg1)->readlines(arg2);
7518
7519 wxPyEndAllowThreads(__tstate);
7520 if (PyErr_Occurred()) SWIG_fail;
7521 }
7522 resultobj = result;
7523 return resultobj;
7524 fail:
7525 return NULL;
7526 }
7527
7528
7529 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7530 PyObject *resultobj;
7531 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7532 int arg2 ;
7533 int arg3 = (int) 0 ;
7534 PyObject * obj0 = 0 ;
7535 PyObject * obj1 = 0 ;
7536 PyObject * obj2 = 0 ;
7537 char *kwnames[] = {
7538 (char *) "self",(char *) "offset",(char *) "whence", NULL
7539 };
7540
7541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7543 if (SWIG_arg_fail(1)) SWIG_fail;
7544 {
7545 arg2 = (int)(SWIG_As_int(obj1));
7546 if (SWIG_arg_fail(2)) SWIG_fail;
7547 }
7548 if (obj2) {
7549 {
7550 arg3 = (int)(SWIG_As_int(obj2));
7551 if (SWIG_arg_fail(3)) SWIG_fail;
7552 }
7553 }
7554 {
7555 PyThreadState* __tstate = wxPyBeginAllowThreads();
7556 (arg1)->seek(arg2,arg3);
7557
7558 wxPyEndAllowThreads(__tstate);
7559 if (PyErr_Occurred()) SWIG_fail;
7560 }
7561 Py_INCREF(Py_None); resultobj = Py_None;
7562 return resultobj;
7563 fail:
7564 return NULL;
7565 }
7566
7567
7568 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7569 PyObject *resultobj;
7570 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7571 int result;
7572 PyObject * obj0 = 0 ;
7573 char *kwnames[] = {
7574 (char *) "self", NULL
7575 };
7576
7577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7579 if (SWIG_arg_fail(1)) SWIG_fail;
7580 {
7581 PyThreadState* __tstate = wxPyBeginAllowThreads();
7582 result = (int)(arg1)->tell();
7583
7584 wxPyEndAllowThreads(__tstate);
7585 if (PyErr_Occurred()) SWIG_fail;
7586 }
7587 {
7588 resultobj = SWIG_From_int((int)(result));
7589 }
7590 return resultobj;
7591 fail:
7592 return NULL;
7593 }
7594
7595
7596 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7597 PyObject *resultobj;
7598 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7599 char result;
7600 PyObject * obj0 = 0 ;
7601 char *kwnames[] = {
7602 (char *) "self", NULL
7603 };
7604
7605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7607 if (SWIG_arg_fail(1)) SWIG_fail;
7608 {
7609 PyThreadState* __tstate = wxPyBeginAllowThreads();
7610 result = (char)(arg1)->Peek();
7611
7612 wxPyEndAllowThreads(__tstate);
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 {
7616 resultobj = SWIG_From_char((char)(result));
7617 }
7618 return resultobj;
7619 fail:
7620 return NULL;
7621 }
7622
7623
7624 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7625 PyObject *resultobj;
7626 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7627 char result;
7628 PyObject * obj0 = 0 ;
7629 char *kwnames[] = {
7630 (char *) "self", NULL
7631 };
7632
7633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7635 if (SWIG_arg_fail(1)) SWIG_fail;
7636 {
7637 PyThreadState* __tstate = wxPyBeginAllowThreads();
7638 result = (char)(arg1)->GetC();
7639
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 {
7644 resultobj = SWIG_From_char((char)(result));
7645 }
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7653 PyObject *resultobj;
7654 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7655 size_t result;
7656 PyObject * obj0 = 0 ;
7657 char *kwnames[] = {
7658 (char *) "self", NULL
7659 };
7660
7661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7663 if (SWIG_arg_fail(1)) SWIG_fail;
7664 {
7665 PyThreadState* __tstate = wxPyBeginAllowThreads();
7666 result = (size_t)(arg1)->LastRead();
7667
7668 wxPyEndAllowThreads(__tstate);
7669 if (PyErr_Occurred()) SWIG_fail;
7670 }
7671 {
7672 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7673 }
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7681 PyObject *resultobj;
7682 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7683 bool result;
7684 PyObject * obj0 = 0 ;
7685 char *kwnames[] = {
7686 (char *) "self", NULL
7687 };
7688
7689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7691 if (SWIG_arg_fail(1)) SWIG_fail;
7692 {
7693 PyThreadState* __tstate = wxPyBeginAllowThreads();
7694 result = (bool)(arg1)->CanRead();
7695
7696 wxPyEndAllowThreads(__tstate);
7697 if (PyErr_Occurred()) SWIG_fail;
7698 }
7699 {
7700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7701 }
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7709 PyObject *resultobj;
7710 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7711 bool result;
7712 PyObject * obj0 = 0 ;
7713 char *kwnames[] = {
7714 (char *) "self", NULL
7715 };
7716
7717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7719 if (SWIG_arg_fail(1)) SWIG_fail;
7720 {
7721 PyThreadState* __tstate = wxPyBeginAllowThreads();
7722 result = (bool)(arg1)->Eof();
7723
7724 wxPyEndAllowThreads(__tstate);
7725 if (PyErr_Occurred()) SWIG_fail;
7726 }
7727 {
7728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7729 }
7730 return resultobj;
7731 fail:
7732 return NULL;
7733 }
7734
7735
7736 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7737 PyObject *resultobj;
7738 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7739 char arg2 ;
7740 bool result;
7741 PyObject * obj0 = 0 ;
7742 PyObject * obj1 = 0 ;
7743 char *kwnames[] = {
7744 (char *) "self",(char *) "c", NULL
7745 };
7746
7747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7749 if (SWIG_arg_fail(1)) SWIG_fail;
7750 {
7751 arg2 = (char)(SWIG_As_char(obj1));
7752 if (SWIG_arg_fail(2)) SWIG_fail;
7753 }
7754 {
7755 PyThreadState* __tstate = wxPyBeginAllowThreads();
7756 result = (bool)(arg1)->Ungetch(arg2);
7757
7758 wxPyEndAllowThreads(__tstate);
7759 if (PyErr_Occurred()) SWIG_fail;
7760 }
7761 {
7762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7763 }
7764 return resultobj;
7765 fail:
7766 return NULL;
7767 }
7768
7769
7770 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7771 PyObject *resultobj;
7772 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7773 long arg2 ;
7774 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7775 long result;
7776 PyObject * obj0 = 0 ;
7777 PyObject * obj1 = 0 ;
7778 PyObject * obj2 = 0 ;
7779 char *kwnames[] = {
7780 (char *) "self",(char *) "pos",(char *) "mode", NULL
7781 };
7782
7783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7785 if (SWIG_arg_fail(1)) SWIG_fail;
7786 {
7787 arg2 = (long)(SWIG_As_long(obj1));
7788 if (SWIG_arg_fail(2)) SWIG_fail;
7789 }
7790 if (obj2) {
7791 {
7792 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7793 if (SWIG_arg_fail(3)) SWIG_fail;
7794 }
7795 }
7796 {
7797 PyThreadState* __tstate = wxPyBeginAllowThreads();
7798 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7799
7800 wxPyEndAllowThreads(__tstate);
7801 if (PyErr_Occurred()) SWIG_fail;
7802 }
7803 {
7804 resultobj = SWIG_From_long((long)(result));
7805 }
7806 return resultobj;
7807 fail:
7808 return NULL;
7809 }
7810
7811
7812 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7813 PyObject *resultobj;
7814 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7815 long result;
7816 PyObject * obj0 = 0 ;
7817 char *kwnames[] = {
7818 (char *) "self", NULL
7819 };
7820
7821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7823 if (SWIG_arg_fail(1)) SWIG_fail;
7824 {
7825 PyThreadState* __tstate = wxPyBeginAllowThreads();
7826 result = (long)(arg1)->TellI();
7827
7828 wxPyEndAllowThreads(__tstate);
7829 if (PyErr_Occurred()) SWIG_fail;
7830 }
7831 {
7832 resultobj = SWIG_From_long((long)(result));
7833 }
7834 return resultobj;
7835 fail:
7836 return NULL;
7837 }
7838
7839
7840 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7841 PyObject *obj;
7842 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7843 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7844 Py_INCREF(obj);
7845 return Py_BuildValue((char *)"");
7846 }
7847 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7848 PyObject *resultobj;
7849 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7850 PyObject *arg2 = (PyObject *) 0 ;
7851 PyObject * obj0 = 0 ;
7852 PyObject * obj1 = 0 ;
7853 char *kwnames[] = {
7854 (char *) "self",(char *) "obj", NULL
7855 };
7856
7857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7859 if (SWIG_arg_fail(1)) SWIG_fail;
7860 arg2 = obj1;
7861 {
7862 PyThreadState* __tstate = wxPyBeginAllowThreads();
7863 wxOutputStream_write(arg1,arg2);
7864
7865 wxPyEndAllowThreads(__tstate);
7866 if (PyErr_Occurred()) SWIG_fail;
7867 }
7868 Py_INCREF(Py_None); resultobj = Py_None;
7869 return resultobj;
7870 fail:
7871 return NULL;
7872 }
7873
7874
7875 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7876 PyObject *obj;
7877 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7878 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7879 Py_INCREF(obj);
7880 return Py_BuildValue((char *)"");
7881 }
7882 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj;
7884 wxInputStream *arg1 = (wxInputStream *) 0 ;
7885 wxString *arg2 = 0 ;
7886 wxString *arg3 = 0 ;
7887 wxString *arg4 = 0 ;
7888 wxDateTime arg5 ;
7889 wxFSFile *result;
7890 wxPyInputStream *temp1 ;
7891 bool created1 ;
7892 bool temp2 = false ;
7893 bool temp3 = false ;
7894 bool temp4 = false ;
7895 PyObject * obj0 = 0 ;
7896 PyObject * obj1 = 0 ;
7897 PyObject * obj2 = 0 ;
7898 PyObject * obj3 = 0 ;
7899 PyObject * obj4 = 0 ;
7900 char *kwnames[] = {
7901 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7902 };
7903
7904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7905 {
7906 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7907 arg1 = temp1->m_wxis;
7908 created1 = false;
7909 } else {
7910 PyErr_Clear(); // clear the failure of the wxPyConvert above
7911 arg1 = wxPyCBInputStream_create(obj0, false);
7912 if (arg1 == NULL) {
7913 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7914 SWIG_fail;
7915 }
7916 created1 = true;
7917 }
7918 }
7919 {
7920 arg2 = wxString_in_helper(obj1);
7921 if (arg2 == NULL) SWIG_fail;
7922 temp2 = true;
7923 }
7924 {
7925 arg3 = wxString_in_helper(obj2);
7926 if (arg3 == NULL) SWIG_fail;
7927 temp3 = true;
7928 }
7929 {
7930 arg4 = wxString_in_helper(obj3);
7931 if (arg4 == NULL) SWIG_fail;
7932 temp4 = true;
7933 }
7934 {
7935 wxDateTime * argp;
7936 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7937 if (SWIG_arg_fail(5)) SWIG_fail;
7938 if (argp == NULL) {
7939 SWIG_null_ref("wxDateTime");
7940 }
7941 if (SWIG_arg_fail(5)) SWIG_fail;
7942 arg5 = *argp;
7943 }
7944 {
7945 PyThreadState* __tstate = wxPyBeginAllowThreads();
7946 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7947
7948 wxPyEndAllowThreads(__tstate);
7949 if (PyErr_Occurred()) SWIG_fail;
7950 }
7951 {
7952 resultobj = wxPyMake_wxObject(result, 1);
7953 }
7954 {
7955 if (created1)
7956 delete arg1;
7957 }
7958 {
7959 if (temp2)
7960 delete arg2;
7961 }
7962 {
7963 if (temp3)
7964 delete arg3;
7965 }
7966 {
7967 if (temp4)
7968 delete arg4;
7969 }
7970 return resultobj;
7971 fail:
7972 {
7973 if (created1)
7974 delete arg1;
7975 }
7976 {
7977 if (temp2)
7978 delete arg2;
7979 }
7980 {
7981 if (temp3)
7982 delete arg3;
7983 }
7984 {
7985 if (temp4)
7986 delete arg4;
7987 }
7988 return NULL;
7989 }
7990
7991
7992 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7993 PyObject *resultobj;
7994 wxFSFile *arg1 = (wxFSFile *) 0 ;
7995 PyObject * obj0 = 0 ;
7996 char *kwnames[] = {
7997 (char *) "self", NULL
7998 };
7999
8000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8002 if (SWIG_arg_fail(1)) SWIG_fail;
8003 {
8004 PyThreadState* __tstate = wxPyBeginAllowThreads();
8005 delete arg1;
8006
8007 wxPyEndAllowThreads(__tstate);
8008 if (PyErr_Occurred()) SWIG_fail;
8009 }
8010 Py_INCREF(Py_None); resultobj = Py_None;
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8018 PyObject *resultobj;
8019 wxFSFile *arg1 = (wxFSFile *) 0 ;
8020 wxInputStream *result;
8021 PyObject * obj0 = 0 ;
8022 char *kwnames[] = {
8023 (char *) "self", NULL
8024 };
8025
8026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8028 if (SWIG_arg_fail(1)) SWIG_fail;
8029 {
8030 PyThreadState* __tstate = wxPyBeginAllowThreads();
8031 result = (wxInputStream *)(arg1)->GetStream();
8032
8033 wxPyEndAllowThreads(__tstate);
8034 if (PyErr_Occurred()) SWIG_fail;
8035 }
8036 {
8037 wxPyInputStream * _ptr = NULL;
8038
8039 if (result) {
8040 _ptr = new wxPyInputStream(result);
8041 }
8042 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8043 }
8044 return resultobj;
8045 fail:
8046 return NULL;
8047 }
8048
8049
8050 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8051 PyObject *resultobj;
8052 wxFSFile *arg1 = (wxFSFile *) 0 ;
8053 wxString *result;
8054 PyObject * obj0 = 0 ;
8055 char *kwnames[] = {
8056 (char *) "self", NULL
8057 };
8058
8059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8061 if (SWIG_arg_fail(1)) SWIG_fail;
8062 {
8063 PyThreadState* __tstate = wxPyBeginAllowThreads();
8064 {
8065 wxString const &_result_ref = (arg1)->GetMimeType();
8066 result = (wxString *) &_result_ref;
8067 }
8068
8069 wxPyEndAllowThreads(__tstate);
8070 if (PyErr_Occurred()) SWIG_fail;
8071 }
8072 {
8073 #if wxUSE_UNICODE
8074 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8075 #else
8076 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8077 #endif
8078 }
8079 return resultobj;
8080 fail:
8081 return NULL;
8082 }
8083
8084
8085 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8086 PyObject *resultobj;
8087 wxFSFile *arg1 = (wxFSFile *) 0 ;
8088 wxString *result;
8089 PyObject * obj0 = 0 ;
8090 char *kwnames[] = {
8091 (char *) "self", NULL
8092 };
8093
8094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8096 if (SWIG_arg_fail(1)) SWIG_fail;
8097 {
8098 PyThreadState* __tstate = wxPyBeginAllowThreads();
8099 {
8100 wxString const &_result_ref = (arg1)->GetLocation();
8101 result = (wxString *) &_result_ref;
8102 }
8103
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 {
8108 #if wxUSE_UNICODE
8109 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8110 #else
8111 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8112 #endif
8113 }
8114 return resultobj;
8115 fail:
8116 return NULL;
8117 }
8118
8119
8120 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8121 PyObject *resultobj;
8122 wxFSFile *arg1 = (wxFSFile *) 0 ;
8123 wxString *result;
8124 PyObject * obj0 = 0 ;
8125 char *kwnames[] = {
8126 (char *) "self", NULL
8127 };
8128
8129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8131 if (SWIG_arg_fail(1)) SWIG_fail;
8132 {
8133 PyThreadState* __tstate = wxPyBeginAllowThreads();
8134 {
8135 wxString const &_result_ref = (arg1)->GetAnchor();
8136 result = (wxString *) &_result_ref;
8137 }
8138
8139 wxPyEndAllowThreads(__tstate);
8140 if (PyErr_Occurred()) SWIG_fail;
8141 }
8142 {
8143 #if wxUSE_UNICODE
8144 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8145 #else
8146 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8147 #endif
8148 }
8149 return resultobj;
8150 fail:
8151 return NULL;
8152 }
8153
8154
8155 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8156 PyObject *resultobj;
8157 wxFSFile *arg1 = (wxFSFile *) 0 ;
8158 wxDateTime result;
8159 PyObject * obj0 = 0 ;
8160 char *kwnames[] = {
8161 (char *) "self", NULL
8162 };
8163
8164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8166 if (SWIG_arg_fail(1)) SWIG_fail;
8167 {
8168 PyThreadState* __tstate = wxPyBeginAllowThreads();
8169 result = (arg1)->GetModificationTime();
8170
8171 wxPyEndAllowThreads(__tstate);
8172 if (PyErr_Occurred()) SWIG_fail;
8173 }
8174 {
8175 wxDateTime * resultptr;
8176 resultptr = new wxDateTime((wxDateTime &)(result));
8177 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8178 }
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8186 PyObject *obj;
8187 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8188 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8189 Py_INCREF(obj);
8190 return Py_BuildValue((char *)"");
8191 }
8192 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8193 PyObject *obj;
8194 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8195 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8196 Py_INCREF(obj);
8197 return Py_BuildValue((char *)"");
8198 }
8199 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8200 PyObject *resultobj;
8201 wxPyFileSystemHandler *result;
8202 char *kwnames[] = {
8203 NULL
8204 };
8205
8206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8207 {
8208 PyThreadState* __tstate = wxPyBeginAllowThreads();
8209 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8210
8211 wxPyEndAllowThreads(__tstate);
8212 if (PyErr_Occurred()) SWIG_fail;
8213 }
8214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8215 return resultobj;
8216 fail:
8217 return NULL;
8218 }
8219
8220
8221 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8222 PyObject *resultobj;
8223 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8224 PyObject *arg2 = (PyObject *) 0 ;
8225 PyObject *arg3 = (PyObject *) 0 ;
8226 PyObject * obj0 = 0 ;
8227 PyObject * obj1 = 0 ;
8228 PyObject * obj2 = 0 ;
8229 char *kwnames[] = {
8230 (char *) "self",(char *) "self",(char *) "_class", NULL
8231 };
8232
8233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8235 if (SWIG_arg_fail(1)) SWIG_fail;
8236 arg2 = obj1;
8237 arg3 = obj2;
8238 {
8239 PyThreadState* __tstate = wxPyBeginAllowThreads();
8240 (arg1)->_setCallbackInfo(arg2,arg3);
8241
8242 wxPyEndAllowThreads(__tstate);
8243 if (PyErr_Occurred()) SWIG_fail;
8244 }
8245 Py_INCREF(Py_None); resultobj = Py_None;
8246 return resultobj;
8247 fail:
8248 return NULL;
8249 }
8250
8251
8252 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8253 PyObject *resultobj;
8254 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8255 wxString *arg2 = 0 ;
8256 bool result;
8257 bool temp2 = false ;
8258 PyObject * obj0 = 0 ;
8259 PyObject * obj1 = 0 ;
8260 char *kwnames[] = {
8261 (char *) "self",(char *) "location", NULL
8262 };
8263
8264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8266 if (SWIG_arg_fail(1)) SWIG_fail;
8267 {
8268 arg2 = wxString_in_helper(obj1);
8269 if (arg2 == NULL) SWIG_fail;
8270 temp2 = true;
8271 }
8272 {
8273 PyThreadState* __tstate = wxPyBeginAllowThreads();
8274 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8275
8276 wxPyEndAllowThreads(__tstate);
8277 if (PyErr_Occurred()) SWIG_fail;
8278 }
8279 {
8280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8281 }
8282 {
8283 if (temp2)
8284 delete arg2;
8285 }
8286 return resultobj;
8287 fail:
8288 {
8289 if (temp2)
8290 delete arg2;
8291 }
8292 return NULL;
8293 }
8294
8295
8296 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8297 PyObject *resultobj;
8298 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8299 wxFileSystem *arg2 = 0 ;
8300 wxString *arg3 = 0 ;
8301 wxFSFile *result;
8302 bool temp3 = false ;
8303 PyObject * obj0 = 0 ;
8304 PyObject * obj1 = 0 ;
8305 PyObject * obj2 = 0 ;
8306 char *kwnames[] = {
8307 (char *) "self",(char *) "fs",(char *) "location", NULL
8308 };
8309
8310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8312 if (SWIG_arg_fail(1)) SWIG_fail;
8313 {
8314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8315 if (SWIG_arg_fail(2)) SWIG_fail;
8316 if (arg2 == NULL) {
8317 SWIG_null_ref("wxFileSystem");
8318 }
8319 if (SWIG_arg_fail(2)) SWIG_fail;
8320 }
8321 {
8322 arg3 = wxString_in_helper(obj2);
8323 if (arg3 == NULL) SWIG_fail;
8324 temp3 = true;
8325 }
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8329
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 {
8334 resultobj = wxPyMake_wxObject(result, 1);
8335 }
8336 {
8337 if (temp3)
8338 delete arg3;
8339 }
8340 return resultobj;
8341 fail:
8342 {
8343 if (temp3)
8344 delete arg3;
8345 }
8346 return NULL;
8347 }
8348
8349
8350 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8351 PyObject *resultobj;
8352 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8353 wxString *arg2 = 0 ;
8354 int arg3 = (int) 0 ;
8355 wxString result;
8356 bool temp2 = false ;
8357 PyObject * obj0 = 0 ;
8358 PyObject * obj1 = 0 ;
8359 PyObject * obj2 = 0 ;
8360 char *kwnames[] = {
8361 (char *) "self",(char *) "spec",(char *) "flags", NULL
8362 };
8363
8364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8366 if (SWIG_arg_fail(1)) SWIG_fail;
8367 {
8368 arg2 = wxString_in_helper(obj1);
8369 if (arg2 == NULL) SWIG_fail;
8370 temp2 = true;
8371 }
8372 if (obj2) {
8373 {
8374 arg3 = (int)(SWIG_As_int(obj2));
8375 if (SWIG_arg_fail(3)) SWIG_fail;
8376 }
8377 }
8378 {
8379 PyThreadState* __tstate = wxPyBeginAllowThreads();
8380 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8381
8382 wxPyEndAllowThreads(__tstate);
8383 if (PyErr_Occurred()) SWIG_fail;
8384 }
8385 {
8386 #if wxUSE_UNICODE
8387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8388 #else
8389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8390 #endif
8391 }
8392 {
8393 if (temp2)
8394 delete arg2;
8395 }
8396 return resultobj;
8397 fail:
8398 {
8399 if (temp2)
8400 delete arg2;
8401 }
8402 return NULL;
8403 }
8404
8405
8406 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8407 PyObject *resultobj;
8408 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8409 wxString result;
8410 PyObject * obj0 = 0 ;
8411 char *kwnames[] = {
8412 (char *) "self", NULL
8413 };
8414
8415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8417 if (SWIG_arg_fail(1)) SWIG_fail;
8418 {
8419 PyThreadState* __tstate = wxPyBeginAllowThreads();
8420 result = (arg1)->FindNext();
8421
8422 wxPyEndAllowThreads(__tstate);
8423 if (PyErr_Occurred()) SWIG_fail;
8424 }
8425 {
8426 #if wxUSE_UNICODE
8427 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8428 #else
8429 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8430 #endif
8431 }
8432 return resultobj;
8433 fail:
8434 return NULL;
8435 }
8436
8437
8438 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8439 PyObject *resultobj;
8440 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8441 wxString *arg2 = 0 ;
8442 wxString result;
8443 bool temp2 = false ;
8444 PyObject * obj0 = 0 ;
8445 PyObject * obj1 = 0 ;
8446 char *kwnames[] = {
8447 (char *) "self",(char *) "location", NULL
8448 };
8449
8450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8452 if (SWIG_arg_fail(1)) SWIG_fail;
8453 {
8454 arg2 = wxString_in_helper(obj1);
8455 if (arg2 == NULL) SWIG_fail;
8456 temp2 = true;
8457 }
8458 {
8459 PyThreadState* __tstate = wxPyBeginAllowThreads();
8460 result = (arg1)->GetProtocol((wxString const &)*arg2);
8461
8462 wxPyEndAllowThreads(__tstate);
8463 if (PyErr_Occurred()) SWIG_fail;
8464 }
8465 {
8466 #if wxUSE_UNICODE
8467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8468 #else
8469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8470 #endif
8471 }
8472 {
8473 if (temp2)
8474 delete arg2;
8475 }
8476 return resultobj;
8477 fail:
8478 {
8479 if (temp2)
8480 delete arg2;
8481 }
8482 return NULL;
8483 }
8484
8485
8486 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8487 PyObject *resultobj;
8488 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8489 wxString *arg2 = 0 ;
8490 wxString result;
8491 bool temp2 = false ;
8492 PyObject * obj0 = 0 ;
8493 PyObject * obj1 = 0 ;
8494 char *kwnames[] = {
8495 (char *) "self",(char *) "location", NULL
8496 };
8497
8498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8500 if (SWIG_arg_fail(1)) SWIG_fail;
8501 {
8502 arg2 = wxString_in_helper(obj1);
8503 if (arg2 == NULL) SWIG_fail;
8504 temp2 = true;
8505 }
8506 {
8507 PyThreadState* __tstate = wxPyBeginAllowThreads();
8508 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8509
8510 wxPyEndAllowThreads(__tstate);
8511 if (PyErr_Occurred()) SWIG_fail;
8512 }
8513 {
8514 #if wxUSE_UNICODE
8515 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8516 #else
8517 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8518 #endif
8519 }
8520 {
8521 if (temp2)
8522 delete arg2;
8523 }
8524 return resultobj;
8525 fail:
8526 {
8527 if (temp2)
8528 delete arg2;
8529 }
8530 return NULL;
8531 }
8532
8533
8534 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8535 PyObject *resultobj;
8536 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8537 wxString *arg2 = 0 ;
8538 wxString result;
8539 bool temp2 = false ;
8540 PyObject * obj0 = 0 ;
8541 PyObject * obj1 = 0 ;
8542 char *kwnames[] = {
8543 (char *) "self",(char *) "location", NULL
8544 };
8545
8546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8548 if (SWIG_arg_fail(1)) SWIG_fail;
8549 {
8550 arg2 = wxString_in_helper(obj1);
8551 if (arg2 == NULL) SWIG_fail;
8552 temp2 = true;
8553 }
8554 {
8555 PyThreadState* __tstate = wxPyBeginAllowThreads();
8556 result = (arg1)->GetAnchor((wxString const &)*arg2);
8557
8558 wxPyEndAllowThreads(__tstate);
8559 if (PyErr_Occurred()) SWIG_fail;
8560 }
8561 {
8562 #if wxUSE_UNICODE
8563 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8564 #else
8565 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8566 #endif
8567 }
8568 {
8569 if (temp2)
8570 delete arg2;
8571 }
8572 return resultobj;
8573 fail:
8574 {
8575 if (temp2)
8576 delete arg2;
8577 }
8578 return NULL;
8579 }
8580
8581
8582 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8583 PyObject *resultobj;
8584 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8585 wxString *arg2 = 0 ;
8586 wxString result;
8587 bool temp2 = false ;
8588 PyObject * obj0 = 0 ;
8589 PyObject * obj1 = 0 ;
8590 char *kwnames[] = {
8591 (char *) "self",(char *) "location", NULL
8592 };
8593
8594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8596 if (SWIG_arg_fail(1)) SWIG_fail;
8597 {
8598 arg2 = wxString_in_helper(obj1);
8599 if (arg2 == NULL) SWIG_fail;
8600 temp2 = true;
8601 }
8602 {
8603 PyThreadState* __tstate = wxPyBeginAllowThreads();
8604 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8605
8606 wxPyEndAllowThreads(__tstate);
8607 if (PyErr_Occurred()) SWIG_fail;
8608 }
8609 {
8610 #if wxUSE_UNICODE
8611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8612 #else
8613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8614 #endif
8615 }
8616 {
8617 if (temp2)
8618 delete arg2;
8619 }
8620 return resultobj;
8621 fail:
8622 {
8623 if (temp2)
8624 delete arg2;
8625 }
8626 return NULL;
8627 }
8628
8629
8630 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8631 PyObject *resultobj;
8632 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8633 wxString *arg2 = 0 ;
8634 wxString result;
8635 bool temp2 = false ;
8636 PyObject * obj0 = 0 ;
8637 PyObject * obj1 = 0 ;
8638 char *kwnames[] = {
8639 (char *) "self",(char *) "location", NULL
8640 };
8641
8642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8644 if (SWIG_arg_fail(1)) SWIG_fail;
8645 {
8646 arg2 = wxString_in_helper(obj1);
8647 if (arg2 == NULL) SWIG_fail;
8648 temp2 = true;
8649 }
8650 {
8651 PyThreadState* __tstate = wxPyBeginAllowThreads();
8652 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8653
8654 wxPyEndAllowThreads(__tstate);
8655 if (PyErr_Occurred()) SWIG_fail;
8656 }
8657 {
8658 #if wxUSE_UNICODE
8659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8660 #else
8661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8662 #endif
8663 }
8664 {
8665 if (temp2)
8666 delete arg2;
8667 }
8668 return resultobj;
8669 fail:
8670 {
8671 if (temp2)
8672 delete arg2;
8673 }
8674 return NULL;
8675 }
8676
8677
8678 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8679 PyObject *obj;
8680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8681 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8682 Py_INCREF(obj);
8683 return Py_BuildValue((char *)"");
8684 }
8685 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8686 PyObject *resultobj;
8687 wxFileSystem *result;
8688 char *kwnames[] = {
8689 NULL
8690 };
8691
8692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8693 {
8694 PyThreadState* __tstate = wxPyBeginAllowThreads();
8695 result = (wxFileSystem *)new wxFileSystem();
8696
8697 wxPyEndAllowThreads(__tstate);
8698 if (PyErr_Occurred()) SWIG_fail;
8699 }
8700 {
8701 resultobj = wxPyMake_wxObject(result, 1);
8702 }
8703 return resultobj;
8704 fail:
8705 return NULL;
8706 }
8707
8708
8709 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8710 PyObject *resultobj;
8711 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8712 PyObject * obj0 = 0 ;
8713 char *kwnames[] = {
8714 (char *) "self", NULL
8715 };
8716
8717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8719 if (SWIG_arg_fail(1)) SWIG_fail;
8720 {
8721 PyThreadState* __tstate = wxPyBeginAllowThreads();
8722 delete arg1;
8723
8724 wxPyEndAllowThreads(__tstate);
8725 if (PyErr_Occurred()) SWIG_fail;
8726 }
8727 Py_INCREF(Py_None); resultobj = Py_None;
8728 return resultobj;
8729 fail:
8730 return NULL;
8731 }
8732
8733
8734 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8735 PyObject *resultobj;
8736 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8737 wxString *arg2 = 0 ;
8738 bool arg3 = (bool) false ;
8739 bool temp2 = false ;
8740 PyObject * obj0 = 0 ;
8741 PyObject * obj1 = 0 ;
8742 PyObject * obj2 = 0 ;
8743 char *kwnames[] = {
8744 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8745 };
8746
8747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8749 if (SWIG_arg_fail(1)) SWIG_fail;
8750 {
8751 arg2 = wxString_in_helper(obj1);
8752 if (arg2 == NULL) SWIG_fail;
8753 temp2 = true;
8754 }
8755 if (obj2) {
8756 {
8757 arg3 = (bool)(SWIG_As_bool(obj2));
8758 if (SWIG_arg_fail(3)) SWIG_fail;
8759 }
8760 }
8761 {
8762 PyThreadState* __tstate = wxPyBeginAllowThreads();
8763 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8764
8765 wxPyEndAllowThreads(__tstate);
8766 if (PyErr_Occurred()) SWIG_fail;
8767 }
8768 Py_INCREF(Py_None); resultobj = Py_None;
8769 {
8770 if (temp2)
8771 delete arg2;
8772 }
8773 return resultobj;
8774 fail:
8775 {
8776 if (temp2)
8777 delete arg2;
8778 }
8779 return NULL;
8780 }
8781
8782
8783 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8784 PyObject *resultobj;
8785 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8786 wxString result;
8787 PyObject * obj0 = 0 ;
8788 char *kwnames[] = {
8789 (char *) "self", NULL
8790 };
8791
8792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8794 if (SWIG_arg_fail(1)) SWIG_fail;
8795 {
8796 PyThreadState* __tstate = wxPyBeginAllowThreads();
8797 result = (arg1)->GetPath();
8798
8799 wxPyEndAllowThreads(__tstate);
8800 if (PyErr_Occurred()) SWIG_fail;
8801 }
8802 {
8803 #if wxUSE_UNICODE
8804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8805 #else
8806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8807 #endif
8808 }
8809 return resultobj;
8810 fail:
8811 return NULL;
8812 }
8813
8814
8815 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8816 PyObject *resultobj;
8817 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8818 wxString *arg2 = 0 ;
8819 wxFSFile *result;
8820 bool temp2 = false ;
8821 PyObject * obj0 = 0 ;
8822 PyObject * obj1 = 0 ;
8823 char *kwnames[] = {
8824 (char *) "self",(char *) "location", NULL
8825 };
8826
8827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8829 if (SWIG_arg_fail(1)) SWIG_fail;
8830 {
8831 arg2 = wxString_in_helper(obj1);
8832 if (arg2 == NULL) SWIG_fail;
8833 temp2 = true;
8834 }
8835 {
8836 PyThreadState* __tstate = wxPyBeginAllowThreads();
8837 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8838
8839 wxPyEndAllowThreads(__tstate);
8840 if (PyErr_Occurred()) SWIG_fail;
8841 }
8842 {
8843 resultobj = wxPyMake_wxObject(result, 1);
8844 }
8845 {
8846 if (temp2)
8847 delete arg2;
8848 }
8849 return resultobj;
8850 fail:
8851 {
8852 if (temp2)
8853 delete arg2;
8854 }
8855 return NULL;
8856 }
8857
8858
8859 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8860 PyObject *resultobj;
8861 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8862 wxString *arg2 = 0 ;
8863 int arg3 = (int) 0 ;
8864 wxString result;
8865 bool temp2 = false ;
8866 PyObject * obj0 = 0 ;
8867 PyObject * obj1 = 0 ;
8868 PyObject * obj2 = 0 ;
8869 char *kwnames[] = {
8870 (char *) "self",(char *) "spec",(char *) "flags", NULL
8871 };
8872
8873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8875 if (SWIG_arg_fail(1)) SWIG_fail;
8876 {
8877 arg2 = wxString_in_helper(obj1);
8878 if (arg2 == NULL) SWIG_fail;
8879 temp2 = true;
8880 }
8881 if (obj2) {
8882 {
8883 arg3 = (int)(SWIG_As_int(obj2));
8884 if (SWIG_arg_fail(3)) SWIG_fail;
8885 }
8886 }
8887 {
8888 PyThreadState* __tstate = wxPyBeginAllowThreads();
8889 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8890
8891 wxPyEndAllowThreads(__tstate);
8892 if (PyErr_Occurred()) SWIG_fail;
8893 }
8894 {
8895 #if wxUSE_UNICODE
8896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8897 #else
8898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8899 #endif
8900 }
8901 {
8902 if (temp2)
8903 delete arg2;
8904 }
8905 return resultobj;
8906 fail:
8907 {
8908 if (temp2)
8909 delete arg2;
8910 }
8911 return NULL;
8912 }
8913
8914
8915 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8916 PyObject *resultobj;
8917 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8918 wxString result;
8919 PyObject * obj0 = 0 ;
8920 char *kwnames[] = {
8921 (char *) "self", NULL
8922 };
8923
8924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8926 if (SWIG_arg_fail(1)) SWIG_fail;
8927 {
8928 PyThreadState* __tstate = wxPyBeginAllowThreads();
8929 result = (arg1)->FindNext();
8930
8931 wxPyEndAllowThreads(__tstate);
8932 if (PyErr_Occurred()) SWIG_fail;
8933 }
8934 {
8935 #if wxUSE_UNICODE
8936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8937 #else
8938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8939 #endif
8940 }
8941 return resultobj;
8942 fail:
8943 return NULL;
8944 }
8945
8946
8947 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8948 PyObject *resultobj;
8949 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8950 PyObject * obj0 = 0 ;
8951 char *kwnames[] = {
8952 (char *) "handler", NULL
8953 };
8954
8955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8957 if (SWIG_arg_fail(1)) SWIG_fail;
8958 {
8959 PyThreadState* __tstate = wxPyBeginAllowThreads();
8960 wxFileSystem::AddHandler(arg1);
8961
8962 wxPyEndAllowThreads(__tstate);
8963 if (PyErr_Occurred()) SWIG_fail;
8964 }
8965 Py_INCREF(Py_None); resultobj = Py_None;
8966 return resultobj;
8967 fail:
8968 return NULL;
8969 }
8970
8971
8972 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8973 PyObject *resultobj;
8974 char *kwnames[] = {
8975 NULL
8976 };
8977
8978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8979 {
8980 PyThreadState* __tstate = wxPyBeginAllowThreads();
8981 wxFileSystem::CleanUpHandlers();
8982
8983 wxPyEndAllowThreads(__tstate);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 Py_INCREF(Py_None); resultobj = Py_None;
8987 return resultobj;
8988 fail:
8989 return NULL;
8990 }
8991
8992
8993 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
8994 PyObject *resultobj;
8995 wxString *arg1 = 0 ;
8996 wxString result;
8997 bool temp1 = false ;
8998 PyObject * obj0 = 0 ;
8999 char *kwnames[] = {
9000 (char *) "filename", NULL
9001 };
9002
9003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9004 {
9005 arg1 = wxString_in_helper(obj0);
9006 if (arg1 == NULL) SWIG_fail;
9007 temp1 = true;
9008 }
9009 {
9010 PyThreadState* __tstate = wxPyBeginAllowThreads();
9011 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9012
9013 wxPyEndAllowThreads(__tstate);
9014 if (PyErr_Occurred()) SWIG_fail;
9015 }
9016 {
9017 #if wxUSE_UNICODE
9018 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9019 #else
9020 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9021 #endif
9022 }
9023 {
9024 if (temp1)
9025 delete arg1;
9026 }
9027 return resultobj;
9028 fail:
9029 {
9030 if (temp1)
9031 delete arg1;
9032 }
9033 return NULL;
9034 }
9035
9036
9037 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9038 PyObject *resultobj;
9039 wxString *arg1 = 0 ;
9040 wxString result;
9041 bool temp1 = false ;
9042 PyObject * obj0 = 0 ;
9043 char *kwnames[] = {
9044 (char *) "url", NULL
9045 };
9046
9047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9048 {
9049 arg1 = wxString_in_helper(obj0);
9050 if (arg1 == NULL) SWIG_fail;
9051 temp1 = true;
9052 }
9053 {
9054 PyThreadState* __tstate = wxPyBeginAllowThreads();
9055 result = FileSystem_URLToFileName((wxString const &)*arg1);
9056
9057 wxPyEndAllowThreads(__tstate);
9058 if (PyErr_Occurred()) SWIG_fail;
9059 }
9060 {
9061 #if wxUSE_UNICODE
9062 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9063 #else
9064 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9065 #endif
9066 }
9067 {
9068 if (temp1)
9069 delete arg1;
9070 }
9071 return resultobj;
9072 fail:
9073 {
9074 if (temp1)
9075 delete arg1;
9076 }
9077 return NULL;
9078 }
9079
9080
9081 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9082 PyObject *obj;
9083 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9084 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9085 Py_INCREF(obj);
9086 return Py_BuildValue((char *)"");
9087 }
9088 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9089 PyObject *resultobj;
9090 wxInternetFSHandler *result;
9091 char *kwnames[] = {
9092 NULL
9093 };
9094
9095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9099
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9104 return resultobj;
9105 fail:
9106 return NULL;
9107 }
9108
9109
9110 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9111 PyObject *resultobj;
9112 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9113 wxString *arg2 = 0 ;
9114 bool result;
9115 bool temp2 = false ;
9116 PyObject * obj0 = 0 ;
9117 PyObject * obj1 = 0 ;
9118 char *kwnames[] = {
9119 (char *) "self",(char *) "location", NULL
9120 };
9121
9122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9124 if (SWIG_arg_fail(1)) SWIG_fail;
9125 {
9126 arg2 = wxString_in_helper(obj1);
9127 if (arg2 == NULL) SWIG_fail;
9128 temp2 = true;
9129 }
9130 {
9131 PyThreadState* __tstate = wxPyBeginAllowThreads();
9132 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9133
9134 wxPyEndAllowThreads(__tstate);
9135 if (PyErr_Occurred()) SWIG_fail;
9136 }
9137 {
9138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9139 }
9140 {
9141 if (temp2)
9142 delete arg2;
9143 }
9144 return resultobj;
9145 fail:
9146 {
9147 if (temp2)
9148 delete arg2;
9149 }
9150 return NULL;
9151 }
9152
9153
9154 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9155 PyObject *resultobj;
9156 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9157 wxFileSystem *arg2 = 0 ;
9158 wxString *arg3 = 0 ;
9159 wxFSFile *result;
9160 bool temp3 = false ;
9161 PyObject * obj0 = 0 ;
9162 PyObject * obj1 = 0 ;
9163 PyObject * obj2 = 0 ;
9164 char *kwnames[] = {
9165 (char *) "self",(char *) "fs",(char *) "location", NULL
9166 };
9167
9168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9170 if (SWIG_arg_fail(1)) SWIG_fail;
9171 {
9172 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9173 if (SWIG_arg_fail(2)) SWIG_fail;
9174 if (arg2 == NULL) {
9175 SWIG_null_ref("wxFileSystem");
9176 }
9177 if (SWIG_arg_fail(2)) SWIG_fail;
9178 }
9179 {
9180 arg3 = wxString_in_helper(obj2);
9181 if (arg3 == NULL) SWIG_fail;
9182 temp3 = true;
9183 }
9184 {
9185 PyThreadState* __tstate = wxPyBeginAllowThreads();
9186 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9187
9188 wxPyEndAllowThreads(__tstate);
9189 if (PyErr_Occurred()) SWIG_fail;
9190 }
9191 {
9192 resultobj = wxPyMake_wxObject(result, 1);
9193 }
9194 {
9195 if (temp3)
9196 delete arg3;
9197 }
9198 return resultobj;
9199 fail:
9200 {
9201 if (temp3)
9202 delete arg3;
9203 }
9204 return NULL;
9205 }
9206
9207
9208 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9209 PyObject *obj;
9210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9211 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9212 Py_INCREF(obj);
9213 return Py_BuildValue((char *)"");
9214 }
9215 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9216 PyObject *resultobj;
9217 wxZipFSHandler *result;
9218 char *kwnames[] = {
9219 NULL
9220 };
9221
9222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9223 {
9224 PyThreadState* __tstate = wxPyBeginAllowThreads();
9225 result = (wxZipFSHandler *)new wxZipFSHandler();
9226
9227 wxPyEndAllowThreads(__tstate);
9228 if (PyErr_Occurred()) SWIG_fail;
9229 }
9230 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9231 return resultobj;
9232 fail:
9233 return NULL;
9234 }
9235
9236
9237 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9238 PyObject *resultobj;
9239 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9240 wxString *arg2 = 0 ;
9241 bool result;
9242 bool temp2 = false ;
9243 PyObject * obj0 = 0 ;
9244 PyObject * obj1 = 0 ;
9245 char *kwnames[] = {
9246 (char *) "self",(char *) "location", NULL
9247 };
9248
9249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9251 if (SWIG_arg_fail(1)) SWIG_fail;
9252 {
9253 arg2 = wxString_in_helper(obj1);
9254 if (arg2 == NULL) SWIG_fail;
9255 temp2 = true;
9256 }
9257 {
9258 PyThreadState* __tstate = wxPyBeginAllowThreads();
9259 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9260
9261 wxPyEndAllowThreads(__tstate);
9262 if (PyErr_Occurred()) SWIG_fail;
9263 }
9264 {
9265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9266 }
9267 {
9268 if (temp2)
9269 delete arg2;
9270 }
9271 return resultobj;
9272 fail:
9273 {
9274 if (temp2)
9275 delete arg2;
9276 }
9277 return NULL;
9278 }
9279
9280
9281 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9282 PyObject *resultobj;
9283 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9284 wxFileSystem *arg2 = 0 ;
9285 wxString *arg3 = 0 ;
9286 wxFSFile *result;
9287 bool temp3 = false ;
9288 PyObject * obj0 = 0 ;
9289 PyObject * obj1 = 0 ;
9290 PyObject * obj2 = 0 ;
9291 char *kwnames[] = {
9292 (char *) "self",(char *) "fs",(char *) "location", NULL
9293 };
9294
9295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9297 if (SWIG_arg_fail(1)) SWIG_fail;
9298 {
9299 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9300 if (SWIG_arg_fail(2)) SWIG_fail;
9301 if (arg2 == NULL) {
9302 SWIG_null_ref("wxFileSystem");
9303 }
9304 if (SWIG_arg_fail(2)) SWIG_fail;
9305 }
9306 {
9307 arg3 = wxString_in_helper(obj2);
9308 if (arg3 == NULL) SWIG_fail;
9309 temp3 = true;
9310 }
9311 {
9312 PyThreadState* __tstate = wxPyBeginAllowThreads();
9313 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9314
9315 wxPyEndAllowThreads(__tstate);
9316 if (PyErr_Occurred()) SWIG_fail;
9317 }
9318 {
9319 resultobj = wxPyMake_wxObject(result, 1);
9320 }
9321 {
9322 if (temp3)
9323 delete arg3;
9324 }
9325 return resultobj;
9326 fail:
9327 {
9328 if (temp3)
9329 delete arg3;
9330 }
9331 return NULL;
9332 }
9333
9334
9335 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9336 PyObject *resultobj;
9337 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9338 wxString *arg2 = 0 ;
9339 int arg3 = (int) 0 ;
9340 wxString result;
9341 bool temp2 = false ;
9342 PyObject * obj0 = 0 ;
9343 PyObject * obj1 = 0 ;
9344 PyObject * obj2 = 0 ;
9345 char *kwnames[] = {
9346 (char *) "self",(char *) "spec",(char *) "flags", NULL
9347 };
9348
9349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9351 if (SWIG_arg_fail(1)) SWIG_fail;
9352 {
9353 arg2 = wxString_in_helper(obj1);
9354 if (arg2 == NULL) SWIG_fail;
9355 temp2 = true;
9356 }
9357 if (obj2) {
9358 {
9359 arg3 = (int)(SWIG_As_int(obj2));
9360 if (SWIG_arg_fail(3)) SWIG_fail;
9361 }
9362 }
9363 {
9364 PyThreadState* __tstate = wxPyBeginAllowThreads();
9365 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9366
9367 wxPyEndAllowThreads(__tstate);
9368 if (PyErr_Occurred()) SWIG_fail;
9369 }
9370 {
9371 #if wxUSE_UNICODE
9372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9373 #else
9374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9375 #endif
9376 }
9377 {
9378 if (temp2)
9379 delete arg2;
9380 }
9381 return resultobj;
9382 fail:
9383 {
9384 if (temp2)
9385 delete arg2;
9386 }
9387 return NULL;
9388 }
9389
9390
9391 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9392 PyObject *resultobj;
9393 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9394 wxString result;
9395 PyObject * obj0 = 0 ;
9396 char *kwnames[] = {
9397 (char *) "self", NULL
9398 };
9399
9400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9402 if (SWIG_arg_fail(1)) SWIG_fail;
9403 {
9404 PyThreadState* __tstate = wxPyBeginAllowThreads();
9405 result = (arg1)->FindNext();
9406
9407 wxPyEndAllowThreads(__tstate);
9408 if (PyErr_Occurred()) SWIG_fail;
9409 }
9410 {
9411 #if wxUSE_UNICODE
9412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9413 #else
9414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9415 #endif
9416 }
9417 return resultobj;
9418 fail:
9419 return NULL;
9420 }
9421
9422
9423 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9424 PyObject *obj;
9425 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9426 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9427 Py_INCREF(obj);
9428 return Py_BuildValue((char *)"");
9429 }
9430 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9431 PyObject *resultobj;
9432 wxString *arg1 = 0 ;
9433 wxImage *arg2 = 0 ;
9434 long arg3 ;
9435 bool temp1 = false ;
9436 PyObject * obj0 = 0 ;
9437 PyObject * obj1 = 0 ;
9438 PyObject * obj2 = 0 ;
9439 char *kwnames[] = {
9440 (char *) "filename",(char *) "image",(char *) "type", NULL
9441 };
9442
9443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9444 {
9445 arg1 = wxString_in_helper(obj0);
9446 if (arg1 == NULL) SWIG_fail;
9447 temp1 = true;
9448 }
9449 {
9450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9451 if (SWIG_arg_fail(2)) SWIG_fail;
9452 if (arg2 == NULL) {
9453 SWIG_null_ref("wxImage");
9454 }
9455 if (SWIG_arg_fail(2)) SWIG_fail;
9456 }
9457 {
9458 arg3 = (long)(SWIG_As_long(obj2));
9459 if (SWIG_arg_fail(3)) SWIG_fail;
9460 }
9461 {
9462 PyThreadState* __tstate = wxPyBeginAllowThreads();
9463 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9464
9465 wxPyEndAllowThreads(__tstate);
9466 if (PyErr_Occurred()) SWIG_fail;
9467 }
9468 Py_INCREF(Py_None); resultobj = Py_None;
9469 {
9470 if (temp1)
9471 delete arg1;
9472 }
9473 return resultobj;
9474 fail:
9475 {
9476 if (temp1)
9477 delete arg1;
9478 }
9479 return NULL;
9480 }
9481
9482
9483 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9484 PyObject *resultobj;
9485 wxString *arg1 = 0 ;
9486 wxBitmap *arg2 = 0 ;
9487 long arg3 ;
9488 bool temp1 = false ;
9489 PyObject * obj0 = 0 ;
9490 PyObject * obj1 = 0 ;
9491 PyObject * obj2 = 0 ;
9492 char *kwnames[] = {
9493 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9494 };
9495
9496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9497 {
9498 arg1 = wxString_in_helper(obj0);
9499 if (arg1 == NULL) SWIG_fail;
9500 temp1 = true;
9501 }
9502 {
9503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9504 if (SWIG_arg_fail(2)) SWIG_fail;
9505 if (arg2 == NULL) {
9506 SWIG_null_ref("wxBitmap");
9507 }
9508 if (SWIG_arg_fail(2)) SWIG_fail;
9509 }
9510 {
9511 arg3 = (long)(SWIG_As_long(obj2));
9512 if (SWIG_arg_fail(3)) SWIG_fail;
9513 }
9514 {
9515 PyThreadState* __tstate = wxPyBeginAllowThreads();
9516 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9517
9518 wxPyEndAllowThreads(__tstate);
9519 if (PyErr_Occurred()) SWIG_fail;
9520 }
9521 Py_INCREF(Py_None); resultobj = Py_None;
9522 {
9523 if (temp1)
9524 delete arg1;
9525 }
9526 return resultobj;
9527 fail:
9528 {
9529 if (temp1)
9530 delete arg1;
9531 }
9532 return NULL;
9533 }
9534
9535
9536 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9537 PyObject *resultobj;
9538 wxString *arg1 = 0 ;
9539 PyObject *arg2 = (PyObject *) 0 ;
9540 bool temp1 = false ;
9541 PyObject * obj0 = 0 ;
9542 PyObject * obj1 = 0 ;
9543 char *kwnames[] = {
9544 (char *) "filename",(char *) "data", NULL
9545 };
9546
9547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9548 {
9549 arg1 = wxString_in_helper(obj0);
9550 if (arg1 == NULL) SWIG_fail;
9551 temp1 = true;
9552 }
9553 arg2 = obj1;
9554 {
9555 PyThreadState* __tstate = wxPyBeginAllowThreads();
9556 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9557
9558 wxPyEndAllowThreads(__tstate);
9559 if (PyErr_Occurred()) SWIG_fail;
9560 }
9561 Py_INCREF(Py_None); resultobj = Py_None;
9562 {
9563 if (temp1)
9564 delete arg1;
9565 }
9566 return resultobj;
9567 fail:
9568 {
9569 if (temp1)
9570 delete arg1;
9571 }
9572 return NULL;
9573 }
9574
9575
9576 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9577 PyObject *resultobj;
9578 wxMemoryFSHandler *result;
9579 char *kwnames[] = {
9580 NULL
9581 };
9582
9583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9584 {
9585 PyThreadState* __tstate = wxPyBeginAllowThreads();
9586 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9587
9588 wxPyEndAllowThreads(__tstate);
9589 if (PyErr_Occurred()) SWIG_fail;
9590 }
9591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9592 return resultobj;
9593 fail:
9594 return NULL;
9595 }
9596
9597
9598 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9599 PyObject *resultobj;
9600 wxString *arg1 = 0 ;
9601 bool temp1 = false ;
9602 PyObject * obj0 = 0 ;
9603 char *kwnames[] = {
9604 (char *) "filename", NULL
9605 };
9606
9607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9608 {
9609 arg1 = wxString_in_helper(obj0);
9610 if (arg1 == NULL) SWIG_fail;
9611 temp1 = true;
9612 }
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9616
9617 wxPyEndAllowThreads(__tstate);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 Py_INCREF(Py_None); resultobj = Py_None;
9621 {
9622 if (temp1)
9623 delete arg1;
9624 }
9625 return resultobj;
9626 fail:
9627 {
9628 if (temp1)
9629 delete arg1;
9630 }
9631 return NULL;
9632 }
9633
9634
9635 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9636 PyObject *resultobj;
9637 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9638 wxString *arg2 = 0 ;
9639 bool result;
9640 bool temp2 = false ;
9641 PyObject * obj0 = 0 ;
9642 PyObject * obj1 = 0 ;
9643 char *kwnames[] = {
9644 (char *) "self",(char *) "location", NULL
9645 };
9646
9647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9649 if (SWIG_arg_fail(1)) SWIG_fail;
9650 {
9651 arg2 = wxString_in_helper(obj1);
9652 if (arg2 == NULL) SWIG_fail;
9653 temp2 = true;
9654 }
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9658
9659 wxPyEndAllowThreads(__tstate);
9660 if (PyErr_Occurred()) SWIG_fail;
9661 }
9662 {
9663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9664 }
9665 {
9666 if (temp2)
9667 delete arg2;
9668 }
9669 return resultobj;
9670 fail:
9671 {
9672 if (temp2)
9673 delete arg2;
9674 }
9675 return NULL;
9676 }
9677
9678
9679 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9680 PyObject *resultobj;
9681 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9682 wxFileSystem *arg2 = 0 ;
9683 wxString *arg3 = 0 ;
9684 wxFSFile *result;
9685 bool temp3 = false ;
9686 PyObject * obj0 = 0 ;
9687 PyObject * obj1 = 0 ;
9688 PyObject * obj2 = 0 ;
9689 char *kwnames[] = {
9690 (char *) "self",(char *) "fs",(char *) "location", NULL
9691 };
9692
9693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9695 if (SWIG_arg_fail(1)) SWIG_fail;
9696 {
9697 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9698 if (SWIG_arg_fail(2)) SWIG_fail;
9699 if (arg2 == NULL) {
9700 SWIG_null_ref("wxFileSystem");
9701 }
9702 if (SWIG_arg_fail(2)) SWIG_fail;
9703 }
9704 {
9705 arg3 = wxString_in_helper(obj2);
9706 if (arg3 == NULL) SWIG_fail;
9707 temp3 = true;
9708 }
9709 {
9710 PyThreadState* __tstate = wxPyBeginAllowThreads();
9711 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9712
9713 wxPyEndAllowThreads(__tstate);
9714 if (PyErr_Occurred()) SWIG_fail;
9715 }
9716 {
9717 resultobj = wxPyMake_wxObject(result, 1);
9718 }
9719 {
9720 if (temp3)
9721 delete arg3;
9722 }
9723 return resultobj;
9724 fail:
9725 {
9726 if (temp3)
9727 delete arg3;
9728 }
9729 return NULL;
9730 }
9731
9732
9733 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9734 PyObject *resultobj;
9735 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9736 wxString *arg2 = 0 ;
9737 int arg3 = (int) 0 ;
9738 wxString result;
9739 bool temp2 = false ;
9740 PyObject * obj0 = 0 ;
9741 PyObject * obj1 = 0 ;
9742 PyObject * obj2 = 0 ;
9743 char *kwnames[] = {
9744 (char *) "self",(char *) "spec",(char *) "flags", NULL
9745 };
9746
9747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9749 if (SWIG_arg_fail(1)) SWIG_fail;
9750 {
9751 arg2 = wxString_in_helper(obj1);
9752 if (arg2 == NULL) SWIG_fail;
9753 temp2 = true;
9754 }
9755 if (obj2) {
9756 {
9757 arg3 = (int)(SWIG_As_int(obj2));
9758 if (SWIG_arg_fail(3)) SWIG_fail;
9759 }
9760 }
9761 {
9762 PyThreadState* __tstate = wxPyBeginAllowThreads();
9763 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9764
9765 wxPyEndAllowThreads(__tstate);
9766 if (PyErr_Occurred()) SWIG_fail;
9767 }
9768 {
9769 #if wxUSE_UNICODE
9770 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9771 #else
9772 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9773 #endif
9774 }
9775 {
9776 if (temp2)
9777 delete arg2;
9778 }
9779 return resultobj;
9780 fail:
9781 {
9782 if (temp2)
9783 delete arg2;
9784 }
9785 return NULL;
9786 }
9787
9788
9789 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9790 PyObject *resultobj;
9791 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9792 wxString result;
9793 PyObject * obj0 = 0 ;
9794 char *kwnames[] = {
9795 (char *) "self", NULL
9796 };
9797
9798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9800 if (SWIG_arg_fail(1)) SWIG_fail;
9801 {
9802 PyThreadState* __tstate = wxPyBeginAllowThreads();
9803 result = (arg1)->FindNext();
9804
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 {
9809 #if wxUSE_UNICODE
9810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9811 #else
9812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9813 #endif
9814 }
9815 return resultobj;
9816 fail:
9817 return NULL;
9818 }
9819
9820
9821 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9822 PyObject *obj;
9823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9824 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9825 Py_INCREF(obj);
9826 return Py_BuildValue((char *)"");
9827 }
9828 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9829 PyObject *resultobj;
9830 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9831 wxString result;
9832 PyObject * obj0 = 0 ;
9833 char *kwnames[] = {
9834 (char *) "self", NULL
9835 };
9836
9837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9839 if (SWIG_arg_fail(1)) SWIG_fail;
9840 {
9841 PyThreadState* __tstate = wxPyBeginAllowThreads();
9842 result = (arg1)->GetName();
9843
9844 wxPyEndAllowThreads(__tstate);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 {
9848 #if wxUSE_UNICODE
9849 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9850 #else
9851 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9852 #endif
9853 }
9854 return resultobj;
9855 fail:
9856 return NULL;
9857 }
9858
9859
9860 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9861 PyObject *resultobj;
9862 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9863 wxString result;
9864 PyObject * obj0 = 0 ;
9865 char *kwnames[] = {
9866 (char *) "self", NULL
9867 };
9868
9869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9871 if (SWIG_arg_fail(1)) SWIG_fail;
9872 {
9873 PyThreadState* __tstate = wxPyBeginAllowThreads();
9874 result = (arg1)->GetExtension();
9875
9876 wxPyEndAllowThreads(__tstate);
9877 if (PyErr_Occurred()) SWIG_fail;
9878 }
9879 {
9880 #if wxUSE_UNICODE
9881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9882 #else
9883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9884 #endif
9885 }
9886 return resultobj;
9887 fail:
9888 return NULL;
9889 }
9890
9891
9892 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9893 PyObject *resultobj;
9894 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9895 long result;
9896 PyObject * obj0 = 0 ;
9897 char *kwnames[] = {
9898 (char *) "self", NULL
9899 };
9900
9901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9903 if (SWIG_arg_fail(1)) SWIG_fail;
9904 {
9905 PyThreadState* __tstate = wxPyBeginAllowThreads();
9906 result = (long)(arg1)->GetType();
9907
9908 wxPyEndAllowThreads(__tstate);
9909 if (PyErr_Occurred()) SWIG_fail;
9910 }
9911 {
9912 resultobj = SWIG_From_long((long)(result));
9913 }
9914 return resultobj;
9915 fail:
9916 return NULL;
9917 }
9918
9919
9920 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9921 PyObject *resultobj;
9922 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9923 wxString result;
9924 PyObject * obj0 = 0 ;
9925 char *kwnames[] = {
9926 (char *) "self", NULL
9927 };
9928
9929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9931 if (SWIG_arg_fail(1)) SWIG_fail;
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 result = (arg1)->GetMimeType();
9935
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 {
9940 #if wxUSE_UNICODE
9941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9942 #else
9943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9944 #endif
9945 }
9946 return resultobj;
9947 fail:
9948 return NULL;
9949 }
9950
9951
9952 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj;
9954 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9955 wxString *arg2 = 0 ;
9956 bool result;
9957 bool temp2 = false ;
9958 PyObject * obj0 = 0 ;
9959 PyObject * obj1 = 0 ;
9960 char *kwnames[] = {
9961 (char *) "self",(char *) "name", NULL
9962 };
9963
9964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
9965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9966 if (SWIG_arg_fail(1)) SWIG_fail;
9967 {
9968 arg2 = wxString_in_helper(obj1);
9969 if (arg2 == NULL) SWIG_fail;
9970 temp2 = true;
9971 }
9972 {
9973 PyThreadState* __tstate = wxPyBeginAllowThreads();
9974 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9975
9976 wxPyEndAllowThreads(__tstate);
9977 if (PyErr_Occurred()) SWIG_fail;
9978 }
9979 {
9980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9981 }
9982 {
9983 if (temp2)
9984 delete arg2;
9985 }
9986 return resultobj;
9987 fail:
9988 {
9989 if (temp2)
9990 delete arg2;
9991 }
9992 return NULL;
9993 }
9994
9995
9996 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
9997 PyObject *resultobj;
9998 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9999 wxString *arg2 = 0 ;
10000 bool temp2 = false ;
10001 PyObject * obj0 = 0 ;
10002 PyObject * obj1 = 0 ;
10003 char *kwnames[] = {
10004 (char *) "self",(char *) "name", NULL
10005 };
10006
10007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10009 if (SWIG_arg_fail(1)) SWIG_fail;
10010 {
10011 arg2 = wxString_in_helper(obj1);
10012 if (arg2 == NULL) SWIG_fail;
10013 temp2 = true;
10014 }
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 (arg1)->SetName((wxString const &)*arg2);
10018
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 Py_INCREF(Py_None); resultobj = Py_None;
10023 {
10024 if (temp2)
10025 delete arg2;
10026 }
10027 return resultobj;
10028 fail:
10029 {
10030 if (temp2)
10031 delete arg2;
10032 }
10033 return NULL;
10034 }
10035
10036
10037 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10038 PyObject *resultobj;
10039 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10040 wxString *arg2 = 0 ;
10041 bool temp2 = false ;
10042 PyObject * obj0 = 0 ;
10043 PyObject * obj1 = 0 ;
10044 char *kwnames[] = {
10045 (char *) "self",(char *) "extension", NULL
10046 };
10047
10048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10050 if (SWIG_arg_fail(1)) SWIG_fail;
10051 {
10052 arg2 = wxString_in_helper(obj1);
10053 if (arg2 == NULL) SWIG_fail;
10054 temp2 = true;
10055 }
10056 {
10057 PyThreadState* __tstate = wxPyBeginAllowThreads();
10058 (arg1)->SetExtension((wxString const &)*arg2);
10059
10060 wxPyEndAllowThreads(__tstate);
10061 if (PyErr_Occurred()) SWIG_fail;
10062 }
10063 Py_INCREF(Py_None); resultobj = Py_None;
10064 {
10065 if (temp2)
10066 delete arg2;
10067 }
10068 return resultobj;
10069 fail:
10070 {
10071 if (temp2)
10072 delete arg2;
10073 }
10074 return NULL;
10075 }
10076
10077
10078 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10079 PyObject *resultobj;
10080 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10081 long arg2 ;
10082 PyObject * obj0 = 0 ;
10083 PyObject * obj1 = 0 ;
10084 char *kwnames[] = {
10085 (char *) "self",(char *) "type", NULL
10086 };
10087
10088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10090 if (SWIG_arg_fail(1)) SWIG_fail;
10091 {
10092 arg2 = (long)(SWIG_As_long(obj1));
10093 if (SWIG_arg_fail(2)) SWIG_fail;
10094 }
10095 {
10096 PyThreadState* __tstate = wxPyBeginAllowThreads();
10097 (arg1)->SetType(arg2);
10098
10099 wxPyEndAllowThreads(__tstate);
10100 if (PyErr_Occurred()) SWIG_fail;
10101 }
10102 Py_INCREF(Py_None); resultobj = Py_None;
10103 return resultobj;
10104 fail:
10105 return NULL;
10106 }
10107
10108
10109 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10110 PyObject *resultobj;
10111 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10112 wxString *arg2 = 0 ;
10113 bool temp2 = false ;
10114 PyObject * obj0 = 0 ;
10115 PyObject * obj1 = 0 ;
10116 char *kwnames[] = {
10117 (char *) "self",(char *) "mimetype", NULL
10118 };
10119
10120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10122 if (SWIG_arg_fail(1)) SWIG_fail;
10123 {
10124 arg2 = wxString_in_helper(obj1);
10125 if (arg2 == NULL) SWIG_fail;
10126 temp2 = true;
10127 }
10128 {
10129 PyThreadState* __tstate = wxPyBeginAllowThreads();
10130 (arg1)->SetMimeType((wxString const &)*arg2);
10131
10132 wxPyEndAllowThreads(__tstate);
10133 if (PyErr_Occurred()) SWIG_fail;
10134 }
10135 Py_INCREF(Py_None); resultobj = Py_None;
10136 {
10137 if (temp2)
10138 delete arg2;
10139 }
10140 return resultobj;
10141 fail:
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return NULL;
10147 }
10148
10149
10150 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10151 PyObject *obj;
10152 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10153 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10154 Py_INCREF(obj);
10155 return Py_BuildValue((char *)"");
10156 }
10157 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10158 PyObject *resultobj;
10159 wxImageHistogram *result;
10160 char *kwnames[] = {
10161 NULL
10162 };
10163
10164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10165 {
10166 PyThreadState* __tstate = wxPyBeginAllowThreads();
10167 result = (wxImageHistogram *)new wxImageHistogram();
10168
10169 wxPyEndAllowThreads(__tstate);
10170 if (PyErr_Occurred()) SWIG_fail;
10171 }
10172 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10173 return resultobj;
10174 fail:
10175 return NULL;
10176 }
10177
10178
10179 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10180 PyObject *resultobj;
10181 unsigned char arg1 ;
10182 unsigned char arg2 ;
10183 unsigned char arg3 ;
10184 unsigned long result;
10185 PyObject * obj0 = 0 ;
10186 PyObject * obj1 = 0 ;
10187 PyObject * obj2 = 0 ;
10188 char *kwnames[] = {
10189 (char *) "r",(char *) "g",(char *) "b", NULL
10190 };
10191
10192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10193 {
10194 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10195 if (SWIG_arg_fail(1)) SWIG_fail;
10196 }
10197 {
10198 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10199 if (SWIG_arg_fail(2)) SWIG_fail;
10200 }
10201 {
10202 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10203 if (SWIG_arg_fail(3)) SWIG_fail;
10204 }
10205 {
10206 PyThreadState* __tstate = wxPyBeginAllowThreads();
10207 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10208
10209 wxPyEndAllowThreads(__tstate);
10210 if (PyErr_Occurred()) SWIG_fail;
10211 }
10212 {
10213 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10214 }
10215 return resultobj;
10216 fail:
10217 return NULL;
10218 }
10219
10220
10221 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10222 PyObject *resultobj;
10223 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10224 unsigned char *arg2 = (unsigned char *) 0 ;
10225 unsigned char *arg3 = (unsigned char *) 0 ;
10226 unsigned char *arg4 = (unsigned char *) 0 ;
10227 unsigned char arg5 = (unsigned char) 1 ;
10228 unsigned char arg6 = (unsigned char) 0 ;
10229 unsigned char arg7 = (unsigned char) 0 ;
10230 bool result;
10231 unsigned char temp2 ;
10232 int res2 = 0 ;
10233 unsigned char temp3 ;
10234 int res3 = 0 ;
10235 unsigned char temp4 ;
10236 int res4 = 0 ;
10237 PyObject * obj0 = 0 ;
10238 PyObject * obj1 = 0 ;
10239 PyObject * obj2 = 0 ;
10240 PyObject * obj3 = 0 ;
10241 char *kwnames[] = {
10242 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10243 };
10244
10245 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10246 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10247 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10250 if (SWIG_arg_fail(1)) SWIG_fail;
10251 if (obj1) {
10252 {
10253 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10254 if (SWIG_arg_fail(5)) SWIG_fail;
10255 }
10256 }
10257 if (obj2) {
10258 {
10259 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10260 if (SWIG_arg_fail(6)) SWIG_fail;
10261 }
10262 }
10263 if (obj3) {
10264 {
10265 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10266 if (SWIG_arg_fail(7)) SWIG_fail;
10267 }
10268 }
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10272
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 {
10277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10278 }
10279 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10280 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10281 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10282 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10283 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10284 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10285 return resultobj;
10286 fail:
10287 return NULL;
10288 }
10289
10290
10291 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10292 PyObject *obj;
10293 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10294 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10295 Py_INCREF(obj);
10296 return Py_BuildValue((char *)"");
10297 }
10298 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10299 PyObject *resultobj;
10300 wxString *arg1 = 0 ;
10301 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10302 int arg3 = (int) -1 ;
10303 wxImage *result;
10304 bool temp1 = false ;
10305 PyObject * obj0 = 0 ;
10306 PyObject * obj1 = 0 ;
10307 PyObject * obj2 = 0 ;
10308 char *kwnames[] = {
10309 (char *) "name",(char *) "type",(char *) "index", NULL
10310 };
10311
10312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10313 {
10314 arg1 = wxString_in_helper(obj0);
10315 if (arg1 == NULL) SWIG_fail;
10316 temp1 = true;
10317 }
10318 if (obj1) {
10319 {
10320 arg2 = (long)(SWIG_As_long(obj1));
10321 if (SWIG_arg_fail(2)) SWIG_fail;
10322 }
10323 }
10324 if (obj2) {
10325 {
10326 arg3 = (int)(SWIG_As_int(obj2));
10327 if (SWIG_arg_fail(3)) SWIG_fail;
10328 }
10329 }
10330 {
10331 PyThreadState* __tstate = wxPyBeginAllowThreads();
10332 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10333
10334 wxPyEndAllowThreads(__tstate);
10335 if (PyErr_Occurred()) SWIG_fail;
10336 }
10337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10338 {
10339 if (temp1)
10340 delete arg1;
10341 }
10342 return resultobj;
10343 fail:
10344 {
10345 if (temp1)
10346 delete arg1;
10347 }
10348 return NULL;
10349 }
10350
10351
10352 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10353 PyObject *resultobj;
10354 wxImage *arg1 = (wxImage *) 0 ;
10355 PyObject * obj0 = 0 ;
10356 char *kwnames[] = {
10357 (char *) "self", NULL
10358 };
10359
10360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10362 if (SWIG_arg_fail(1)) SWIG_fail;
10363 {
10364 PyThreadState* __tstate = wxPyBeginAllowThreads();
10365 delete arg1;
10366
10367 wxPyEndAllowThreads(__tstate);
10368 if (PyErr_Occurred()) SWIG_fail;
10369 }
10370 Py_INCREF(Py_None); resultobj = Py_None;
10371 return resultobj;
10372 fail:
10373 return NULL;
10374 }
10375
10376
10377 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10378 PyObject *resultobj;
10379 wxString *arg1 = 0 ;
10380 wxString *arg2 = 0 ;
10381 int arg3 = (int) -1 ;
10382 wxImage *result;
10383 bool temp1 = false ;
10384 bool temp2 = false ;
10385 PyObject * obj0 = 0 ;
10386 PyObject * obj1 = 0 ;
10387 PyObject * obj2 = 0 ;
10388 char *kwnames[] = {
10389 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10390 };
10391
10392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10393 {
10394 arg1 = wxString_in_helper(obj0);
10395 if (arg1 == NULL) SWIG_fail;
10396 temp1 = true;
10397 }
10398 {
10399 arg2 = wxString_in_helper(obj1);
10400 if (arg2 == NULL) SWIG_fail;
10401 temp2 = true;
10402 }
10403 if (obj2) {
10404 {
10405 arg3 = (int)(SWIG_As_int(obj2));
10406 if (SWIG_arg_fail(3)) SWIG_fail;
10407 }
10408 }
10409 {
10410 PyThreadState* __tstate = wxPyBeginAllowThreads();
10411 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10412
10413 wxPyEndAllowThreads(__tstate);
10414 if (PyErr_Occurred()) SWIG_fail;
10415 }
10416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10417 {
10418 if (temp1)
10419 delete arg1;
10420 }
10421 {
10422 if (temp2)
10423 delete arg2;
10424 }
10425 return resultobj;
10426 fail:
10427 {
10428 if (temp1)
10429 delete arg1;
10430 }
10431 {
10432 if (temp2)
10433 delete arg2;
10434 }
10435 return NULL;
10436 }
10437
10438
10439 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10440 PyObject *resultobj;
10441 wxInputStream *arg1 = 0 ;
10442 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10443 int arg3 = (int) -1 ;
10444 wxImage *result;
10445 wxPyInputStream *temp1 ;
10446 bool created1 ;
10447 PyObject * obj0 = 0 ;
10448 PyObject * obj1 = 0 ;
10449 PyObject * obj2 = 0 ;
10450 char *kwnames[] = {
10451 (char *) "stream",(char *) "type",(char *) "index", NULL
10452 };
10453
10454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10455 {
10456 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10457 arg1 = temp1->m_wxis;
10458 created1 = false;
10459 } else {
10460 PyErr_Clear(); // clear the failure of the wxPyConvert above
10461 arg1 = wxPyCBInputStream_create(obj0, false);
10462 if (arg1 == NULL) {
10463 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10464 SWIG_fail;
10465 }
10466 created1 = true;
10467 }
10468 }
10469 if (obj1) {
10470 {
10471 arg2 = (long)(SWIG_As_long(obj1));
10472 if (SWIG_arg_fail(2)) SWIG_fail;
10473 }
10474 }
10475 if (obj2) {
10476 {
10477 arg3 = (int)(SWIG_As_int(obj2));
10478 if (SWIG_arg_fail(3)) SWIG_fail;
10479 }
10480 }
10481 {
10482 PyThreadState* __tstate = wxPyBeginAllowThreads();
10483 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10484
10485 wxPyEndAllowThreads(__tstate);
10486 if (PyErr_Occurred()) SWIG_fail;
10487 }
10488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10489 {
10490 if (created1)
10491 delete arg1;
10492 }
10493 return resultobj;
10494 fail:
10495 {
10496 if (created1)
10497 delete arg1;
10498 }
10499 return NULL;
10500 }
10501
10502
10503 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10504 PyObject *resultobj;
10505 wxInputStream *arg1 = 0 ;
10506 wxString *arg2 = 0 ;
10507 int arg3 = (int) -1 ;
10508 wxImage *result;
10509 wxPyInputStream *temp1 ;
10510 bool created1 ;
10511 bool temp2 = false ;
10512 PyObject * obj0 = 0 ;
10513 PyObject * obj1 = 0 ;
10514 PyObject * obj2 = 0 ;
10515 char *kwnames[] = {
10516 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10517 };
10518
10519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10520 {
10521 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10522 arg1 = temp1->m_wxis;
10523 created1 = false;
10524 } else {
10525 PyErr_Clear(); // clear the failure of the wxPyConvert above
10526 arg1 = wxPyCBInputStream_create(obj0, false);
10527 if (arg1 == NULL) {
10528 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10529 SWIG_fail;
10530 }
10531 created1 = true;
10532 }
10533 }
10534 {
10535 arg2 = wxString_in_helper(obj1);
10536 if (arg2 == NULL) SWIG_fail;
10537 temp2 = true;
10538 }
10539 if (obj2) {
10540 {
10541 arg3 = (int)(SWIG_As_int(obj2));
10542 if (SWIG_arg_fail(3)) SWIG_fail;
10543 }
10544 }
10545 {
10546 PyThreadState* __tstate = wxPyBeginAllowThreads();
10547 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10548
10549 wxPyEndAllowThreads(__tstate);
10550 if (PyErr_Occurred()) SWIG_fail;
10551 }
10552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10553 {
10554 if (created1)
10555 delete arg1;
10556 }
10557 {
10558 if (temp2)
10559 delete arg2;
10560 }
10561 return resultobj;
10562 fail:
10563 {
10564 if (created1)
10565 delete arg1;
10566 }
10567 {
10568 if (temp2)
10569 delete arg2;
10570 }
10571 return NULL;
10572 }
10573
10574
10575 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10576 PyObject *resultobj;
10577 int arg1 = (int) 0 ;
10578 int arg2 = (int) 0 ;
10579 bool arg3 = (bool) true ;
10580 wxImage *result;
10581 PyObject * obj0 = 0 ;
10582 PyObject * obj1 = 0 ;
10583 PyObject * obj2 = 0 ;
10584 char *kwnames[] = {
10585 (char *) "width",(char *) "height",(char *) "clear", NULL
10586 };
10587
10588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10589 if (obj0) {
10590 {
10591 arg1 = (int)(SWIG_As_int(obj0));
10592 if (SWIG_arg_fail(1)) SWIG_fail;
10593 }
10594 }
10595 if (obj1) {
10596 {
10597 arg2 = (int)(SWIG_As_int(obj1));
10598 if (SWIG_arg_fail(2)) SWIG_fail;
10599 }
10600 }
10601 if (obj2) {
10602 {
10603 arg3 = (bool)(SWIG_As_bool(obj2));
10604 if (SWIG_arg_fail(3)) SWIG_fail;
10605 }
10606 }
10607 {
10608 PyThreadState* __tstate = wxPyBeginAllowThreads();
10609 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10610
10611 wxPyEndAllowThreads(__tstate);
10612 if (PyErr_Occurred()) SWIG_fail;
10613 }
10614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10615 return resultobj;
10616 fail:
10617 return NULL;
10618 }
10619
10620
10621 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10622 PyObject *resultobj;
10623 wxBitmap *arg1 = 0 ;
10624 wxImage *result;
10625 PyObject * obj0 = 0 ;
10626 char *kwnames[] = {
10627 (char *) "bitmap", NULL
10628 };
10629
10630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10631 {
10632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10633 if (SWIG_arg_fail(1)) SWIG_fail;
10634 if (arg1 == NULL) {
10635 SWIG_null_ref("wxBitmap");
10636 }
10637 if (SWIG_arg_fail(1)) SWIG_fail;
10638 }
10639 {
10640 if (!wxPyCheckForApp()) SWIG_fail;
10641 PyThreadState* __tstate = wxPyBeginAllowThreads();
10642 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10643
10644 wxPyEndAllowThreads(__tstate);
10645 if (PyErr_Occurred()) SWIG_fail;
10646 }
10647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10648 return resultobj;
10649 fail:
10650 return NULL;
10651 }
10652
10653
10654 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10655 PyObject *resultobj;
10656 int arg1 ;
10657 int arg2 ;
10658 unsigned char *arg3 = (unsigned char *) 0 ;
10659 wxImage *result;
10660 PyObject * obj0 = 0 ;
10661 PyObject * obj1 = 0 ;
10662 PyObject * obj2 = 0 ;
10663 char *kwnames[] = {
10664 (char *) "width",(char *) "height",(char *) "data", NULL
10665 };
10666
10667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10668 {
10669 arg1 = (int)(SWIG_As_int(obj0));
10670 if (SWIG_arg_fail(1)) SWIG_fail;
10671 }
10672 {
10673 arg2 = (int)(SWIG_As_int(obj1));
10674 if (SWIG_arg_fail(2)) SWIG_fail;
10675 }
10676 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10677 if (SWIG_arg_fail(3)) SWIG_fail;
10678 {
10679 PyThreadState* __tstate = wxPyBeginAllowThreads();
10680 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10681
10682 wxPyEndAllowThreads(__tstate);
10683 if (PyErr_Occurred()) SWIG_fail;
10684 }
10685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10686 return resultobj;
10687 fail:
10688 return NULL;
10689 }
10690
10691
10692 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10693 PyObject *resultobj;
10694 int arg1 ;
10695 int arg2 ;
10696 unsigned char *arg3 = (unsigned char *) 0 ;
10697 unsigned char *arg4 = (unsigned char *) 0 ;
10698 wxImage *result;
10699 PyObject * obj0 = 0 ;
10700 PyObject * obj1 = 0 ;
10701 PyObject * obj2 = 0 ;
10702 PyObject * obj3 = 0 ;
10703 char *kwnames[] = {
10704 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10705 };
10706
10707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10708 {
10709 arg1 = (int)(SWIG_As_int(obj0));
10710 if (SWIG_arg_fail(1)) SWIG_fail;
10711 }
10712 {
10713 arg2 = (int)(SWIG_As_int(obj1));
10714 if (SWIG_arg_fail(2)) SWIG_fail;
10715 }
10716 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10717 if (SWIG_arg_fail(3)) SWIG_fail;
10718 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10719 if (SWIG_arg_fail(4)) SWIG_fail;
10720 {
10721 PyThreadState* __tstate = wxPyBeginAllowThreads();
10722 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10723
10724 wxPyEndAllowThreads(__tstate);
10725 if (PyErr_Occurred()) SWIG_fail;
10726 }
10727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10728 return resultobj;
10729 fail:
10730 return NULL;
10731 }
10732
10733
10734 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10735 PyObject *resultobj;
10736 wxImage *arg1 = (wxImage *) 0 ;
10737 int arg2 ;
10738 int arg3 ;
10739 PyObject * obj0 = 0 ;
10740 PyObject * obj1 = 0 ;
10741 PyObject * obj2 = 0 ;
10742 char *kwnames[] = {
10743 (char *) "self",(char *) "width",(char *) "height", NULL
10744 };
10745
10746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10748 if (SWIG_arg_fail(1)) SWIG_fail;
10749 {
10750 arg2 = (int)(SWIG_As_int(obj1));
10751 if (SWIG_arg_fail(2)) SWIG_fail;
10752 }
10753 {
10754 arg3 = (int)(SWIG_As_int(obj2));
10755 if (SWIG_arg_fail(3)) SWIG_fail;
10756 }
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 (arg1)->Create(arg2,arg3);
10760
10761 wxPyEndAllowThreads(__tstate);
10762 if (PyErr_Occurred()) SWIG_fail;
10763 }
10764 Py_INCREF(Py_None); resultobj = Py_None;
10765 return resultobj;
10766 fail:
10767 return NULL;
10768 }
10769
10770
10771 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10772 PyObject *resultobj;
10773 wxImage *arg1 = (wxImage *) 0 ;
10774 PyObject * obj0 = 0 ;
10775 char *kwnames[] = {
10776 (char *) "self", NULL
10777 };
10778
10779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10781 if (SWIG_arg_fail(1)) SWIG_fail;
10782 {
10783 PyThreadState* __tstate = wxPyBeginAllowThreads();
10784 (arg1)->Destroy();
10785
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 Py_INCREF(Py_None); resultobj = Py_None;
10790 return resultobj;
10791 fail:
10792 return NULL;
10793 }
10794
10795
10796 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10797 PyObject *resultobj;
10798 wxImage *arg1 = (wxImage *) 0 ;
10799 int arg2 ;
10800 int arg3 ;
10801 SwigValueWrapper<wxImage > result;
10802 PyObject * obj0 = 0 ;
10803 PyObject * obj1 = 0 ;
10804 PyObject * obj2 = 0 ;
10805 char *kwnames[] = {
10806 (char *) "self",(char *) "width",(char *) "height", NULL
10807 };
10808
10809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10811 if (SWIG_arg_fail(1)) SWIG_fail;
10812 {
10813 arg2 = (int)(SWIG_As_int(obj1));
10814 if (SWIG_arg_fail(2)) SWIG_fail;
10815 }
10816 {
10817 arg3 = (int)(SWIG_As_int(obj2));
10818 if (SWIG_arg_fail(3)) SWIG_fail;
10819 }
10820 {
10821 PyThreadState* __tstate = wxPyBeginAllowThreads();
10822 result = (arg1)->Scale(arg2,arg3);
10823
10824 wxPyEndAllowThreads(__tstate);
10825 if (PyErr_Occurred()) SWIG_fail;
10826 }
10827 {
10828 wxImage * resultptr;
10829 resultptr = new wxImage((wxImage &)(result));
10830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10831 }
10832 return resultobj;
10833 fail:
10834 return NULL;
10835 }
10836
10837
10838 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10839 PyObject *resultobj;
10840 wxImage *arg1 = (wxImage *) 0 ;
10841 int arg2 ;
10842 int arg3 ;
10843 SwigValueWrapper<wxImage > result;
10844 PyObject * obj0 = 0 ;
10845 PyObject * obj1 = 0 ;
10846 PyObject * obj2 = 0 ;
10847 char *kwnames[] = {
10848 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10849 };
10850
10851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10853 if (SWIG_arg_fail(1)) SWIG_fail;
10854 {
10855 arg2 = (int)(SWIG_As_int(obj1));
10856 if (SWIG_arg_fail(2)) SWIG_fail;
10857 }
10858 {
10859 arg3 = (int)(SWIG_As_int(obj2));
10860 if (SWIG_arg_fail(3)) SWIG_fail;
10861 }
10862 {
10863 PyThreadState* __tstate = wxPyBeginAllowThreads();
10864 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10865
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 {
10870 wxImage * resultptr;
10871 resultptr = new wxImage((wxImage &)(result));
10872 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10873 }
10874 return resultobj;
10875 fail:
10876 return NULL;
10877 }
10878
10879
10880 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10881 PyObject *resultobj;
10882 wxImage *arg1 = (wxImage *) 0 ;
10883 int arg2 ;
10884 int arg3 ;
10885 wxImage *result;
10886 PyObject * obj0 = 0 ;
10887 PyObject * obj1 = 0 ;
10888 PyObject * obj2 = 0 ;
10889 char *kwnames[] = {
10890 (char *) "self",(char *) "width",(char *) "height", NULL
10891 };
10892
10893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10895 if (SWIG_arg_fail(1)) SWIG_fail;
10896 {
10897 arg2 = (int)(SWIG_As_int(obj1));
10898 if (SWIG_arg_fail(2)) SWIG_fail;
10899 }
10900 {
10901 arg3 = (int)(SWIG_As_int(obj2));
10902 if (SWIG_arg_fail(3)) SWIG_fail;
10903 }
10904 {
10905 PyThreadState* __tstate = wxPyBeginAllowThreads();
10906 {
10907 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10908 result = (wxImage *) &_result_ref;
10909 }
10910
10911 wxPyEndAllowThreads(__tstate);
10912 if (PyErr_Occurred()) SWIG_fail;
10913 }
10914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10915 return resultobj;
10916 fail:
10917 return NULL;
10918 }
10919
10920
10921 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10922 PyObject *resultobj;
10923 wxImage *arg1 = (wxImage *) 0 ;
10924 int arg2 ;
10925 int arg3 ;
10926 unsigned char arg4 ;
10927 unsigned char arg5 ;
10928 unsigned char arg6 ;
10929 PyObject * obj0 = 0 ;
10930 PyObject * obj1 = 0 ;
10931 PyObject * obj2 = 0 ;
10932 PyObject * obj3 = 0 ;
10933 PyObject * obj4 = 0 ;
10934 PyObject * obj5 = 0 ;
10935 char *kwnames[] = {
10936 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10937 };
10938
10939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10941 if (SWIG_arg_fail(1)) SWIG_fail;
10942 {
10943 arg2 = (int)(SWIG_As_int(obj1));
10944 if (SWIG_arg_fail(2)) SWIG_fail;
10945 }
10946 {
10947 arg3 = (int)(SWIG_As_int(obj2));
10948 if (SWIG_arg_fail(3)) SWIG_fail;
10949 }
10950 {
10951 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10952 if (SWIG_arg_fail(4)) SWIG_fail;
10953 }
10954 {
10955 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10956 if (SWIG_arg_fail(5)) SWIG_fail;
10957 }
10958 {
10959 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10960 if (SWIG_arg_fail(6)) SWIG_fail;
10961 }
10962 {
10963 PyThreadState* __tstate = wxPyBeginAllowThreads();
10964 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10965
10966 wxPyEndAllowThreads(__tstate);
10967 if (PyErr_Occurred()) SWIG_fail;
10968 }
10969 Py_INCREF(Py_None); resultobj = Py_None;
10970 return resultobj;
10971 fail:
10972 return NULL;
10973 }
10974
10975
10976 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10977 PyObject *resultobj;
10978 wxImage *arg1 = (wxImage *) 0 ;
10979 int arg2 ;
10980 int arg3 ;
10981 unsigned char result;
10982 PyObject * obj0 = 0 ;
10983 PyObject * obj1 = 0 ;
10984 PyObject * obj2 = 0 ;
10985 char *kwnames[] = {
10986 (char *) "self",(char *) "x",(char *) "y", NULL
10987 };
10988
10989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10991 if (SWIG_arg_fail(1)) SWIG_fail;
10992 {
10993 arg2 = (int)(SWIG_As_int(obj1));
10994 if (SWIG_arg_fail(2)) SWIG_fail;
10995 }
10996 {
10997 arg3 = (int)(SWIG_As_int(obj2));
10998 if (SWIG_arg_fail(3)) SWIG_fail;
10999 }
11000 {
11001 PyThreadState* __tstate = wxPyBeginAllowThreads();
11002 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11003
11004 wxPyEndAllowThreads(__tstate);
11005 if (PyErr_Occurred()) SWIG_fail;
11006 }
11007 {
11008 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11009 }
11010 return resultobj;
11011 fail:
11012 return NULL;
11013 }
11014
11015
11016 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11017 PyObject *resultobj;
11018 wxImage *arg1 = (wxImage *) 0 ;
11019 int arg2 ;
11020 int arg3 ;
11021 unsigned char result;
11022 PyObject * obj0 = 0 ;
11023 PyObject * obj1 = 0 ;
11024 PyObject * obj2 = 0 ;
11025 char *kwnames[] = {
11026 (char *) "self",(char *) "x",(char *) "y", NULL
11027 };
11028
11029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11031 if (SWIG_arg_fail(1)) SWIG_fail;
11032 {
11033 arg2 = (int)(SWIG_As_int(obj1));
11034 if (SWIG_arg_fail(2)) SWIG_fail;
11035 }
11036 {
11037 arg3 = (int)(SWIG_As_int(obj2));
11038 if (SWIG_arg_fail(3)) SWIG_fail;
11039 }
11040 {
11041 PyThreadState* __tstate = wxPyBeginAllowThreads();
11042 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11043
11044 wxPyEndAllowThreads(__tstate);
11045 if (PyErr_Occurred()) SWIG_fail;
11046 }
11047 {
11048 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11049 }
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj;
11058 wxImage *arg1 = (wxImage *) 0 ;
11059 int arg2 ;
11060 int arg3 ;
11061 unsigned char result;
11062 PyObject * obj0 = 0 ;
11063 PyObject * obj1 = 0 ;
11064 PyObject * obj2 = 0 ;
11065 char *kwnames[] = {
11066 (char *) "self",(char *) "x",(char *) "y", NULL
11067 };
11068
11069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11071 if (SWIG_arg_fail(1)) SWIG_fail;
11072 {
11073 arg2 = (int)(SWIG_As_int(obj1));
11074 if (SWIG_arg_fail(2)) SWIG_fail;
11075 }
11076 {
11077 arg3 = (int)(SWIG_As_int(obj2));
11078 if (SWIG_arg_fail(3)) SWIG_fail;
11079 }
11080 {
11081 PyThreadState* __tstate = wxPyBeginAllowThreads();
11082 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11083
11084 wxPyEndAllowThreads(__tstate);
11085 if (PyErr_Occurred()) SWIG_fail;
11086 }
11087 {
11088 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11089 }
11090 return resultobj;
11091 fail:
11092 return NULL;
11093 }
11094
11095
11096 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11097 PyObject *resultobj;
11098 wxImage *arg1 = (wxImage *) 0 ;
11099 int arg2 ;
11100 int arg3 ;
11101 unsigned char arg4 ;
11102 PyObject * obj0 = 0 ;
11103 PyObject * obj1 = 0 ;
11104 PyObject * obj2 = 0 ;
11105 PyObject * obj3 = 0 ;
11106 char *kwnames[] = {
11107 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11108 };
11109
11110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11112 if (SWIG_arg_fail(1)) SWIG_fail;
11113 {
11114 arg2 = (int)(SWIG_As_int(obj1));
11115 if (SWIG_arg_fail(2)) SWIG_fail;
11116 }
11117 {
11118 arg3 = (int)(SWIG_As_int(obj2));
11119 if (SWIG_arg_fail(3)) SWIG_fail;
11120 }
11121 {
11122 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11123 if (SWIG_arg_fail(4)) SWIG_fail;
11124 }
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 (arg1)->SetAlpha(arg2,arg3,arg4);
11128
11129 wxPyEndAllowThreads(__tstate);
11130 if (PyErr_Occurred()) SWIG_fail;
11131 }
11132 Py_INCREF(Py_None); resultobj = Py_None;
11133 return resultobj;
11134 fail:
11135 return NULL;
11136 }
11137
11138
11139 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11140 PyObject *resultobj;
11141 wxImage *arg1 = (wxImage *) 0 ;
11142 int arg2 ;
11143 int arg3 ;
11144 unsigned char result;
11145 PyObject * obj0 = 0 ;
11146 PyObject * obj1 = 0 ;
11147 PyObject * obj2 = 0 ;
11148 char *kwnames[] = {
11149 (char *) "self",(char *) "x",(char *) "y", NULL
11150 };
11151
11152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11154 if (SWIG_arg_fail(1)) SWIG_fail;
11155 {
11156 arg2 = (int)(SWIG_As_int(obj1));
11157 if (SWIG_arg_fail(2)) SWIG_fail;
11158 }
11159 {
11160 arg3 = (int)(SWIG_As_int(obj2));
11161 if (SWIG_arg_fail(3)) SWIG_fail;
11162 }
11163 {
11164 PyThreadState* __tstate = wxPyBeginAllowThreads();
11165 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11166
11167 wxPyEndAllowThreads(__tstate);
11168 if (PyErr_Occurred()) SWIG_fail;
11169 }
11170 {
11171 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11172 }
11173 return resultobj;
11174 fail:
11175 return NULL;
11176 }
11177
11178
11179 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11180 PyObject *resultobj;
11181 wxImage *arg1 = (wxImage *) 0 ;
11182 bool result;
11183 PyObject * obj0 = 0 ;
11184 char *kwnames[] = {
11185 (char *) "self", NULL
11186 };
11187
11188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11190 if (SWIG_arg_fail(1)) SWIG_fail;
11191 {
11192 PyThreadState* __tstate = wxPyBeginAllowThreads();
11193 result = (bool)(arg1)->HasAlpha();
11194
11195 wxPyEndAllowThreads(__tstate);
11196 if (PyErr_Occurred()) SWIG_fail;
11197 }
11198 {
11199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11200 }
11201 return resultobj;
11202 fail:
11203 return NULL;
11204 }
11205
11206
11207 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11208 PyObject *resultobj;
11209 wxImage *arg1 = (wxImage *) 0 ;
11210 byte *arg2 = (byte *) 0 ;
11211 byte *arg3 = (byte *) 0 ;
11212 byte *arg4 = (byte *) 0 ;
11213 byte arg5 = (byte) 0 ;
11214 byte arg6 = (byte) 0 ;
11215 byte arg7 = (byte) 0 ;
11216 bool result;
11217 byte temp2 ;
11218 int res2 = 0 ;
11219 byte temp3 ;
11220 int res3 = 0 ;
11221 byte temp4 ;
11222 int res4 = 0 ;
11223 PyObject * obj0 = 0 ;
11224 PyObject * obj1 = 0 ;
11225 PyObject * obj2 = 0 ;
11226 PyObject * obj3 = 0 ;
11227 char *kwnames[] = {
11228 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11229 };
11230
11231 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11232 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11233 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11236 if (SWIG_arg_fail(1)) SWIG_fail;
11237 if (obj1) {
11238 {
11239 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11240 if (SWIG_arg_fail(5)) SWIG_fail;
11241 }
11242 }
11243 if (obj2) {
11244 {
11245 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11246 if (SWIG_arg_fail(6)) SWIG_fail;
11247 }
11248 }
11249 if (obj3) {
11250 {
11251 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11252 if (SWIG_arg_fail(7)) SWIG_fail;
11253 }
11254 }
11255 {
11256 PyThreadState* __tstate = wxPyBeginAllowThreads();
11257 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11258
11259 wxPyEndAllowThreads(__tstate);
11260 if (PyErr_Occurred()) SWIG_fail;
11261 }
11262 {
11263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11264 }
11265 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11266 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11267 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11268 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11269 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11270 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11271 return resultobj;
11272 fail:
11273 return NULL;
11274 }
11275
11276
11277 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11278 PyObject *resultobj;
11279 wxImage *arg1 = (wxImage *) 0 ;
11280 byte arg2 = (byte) 128 ;
11281 bool result;
11282 PyObject * obj0 = 0 ;
11283 PyObject * obj1 = 0 ;
11284 char *kwnames[] = {
11285 (char *) "self",(char *) "threshold", NULL
11286 };
11287
11288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11290 if (SWIG_arg_fail(1)) SWIG_fail;
11291 if (obj1) {
11292 {
11293 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11294 if (SWIG_arg_fail(2)) SWIG_fail;
11295 }
11296 }
11297 {
11298 PyThreadState* __tstate = wxPyBeginAllowThreads();
11299 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11300
11301 wxPyEndAllowThreads(__tstate);
11302 if (PyErr_Occurred()) SWIG_fail;
11303 }
11304 {
11305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11306 }
11307 return resultobj;
11308 fail:
11309 return NULL;
11310 }
11311
11312
11313 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11314 PyObject *resultobj;
11315 wxImage *arg1 = (wxImage *) 0 ;
11316 unsigned char arg2 ;
11317 unsigned char arg3 ;
11318 unsigned char arg4 ;
11319 bool result;
11320 PyObject * obj0 = 0 ;
11321 PyObject * obj1 = 0 ;
11322 PyObject * obj2 = 0 ;
11323 PyObject * obj3 = 0 ;
11324 char *kwnames[] = {
11325 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11326 };
11327
11328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11330 if (SWIG_arg_fail(1)) SWIG_fail;
11331 {
11332 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11333 if (SWIG_arg_fail(2)) SWIG_fail;
11334 }
11335 {
11336 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11337 if (SWIG_arg_fail(3)) SWIG_fail;
11338 }
11339 {
11340 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11341 if (SWIG_arg_fail(4)) SWIG_fail;
11342 }
11343 {
11344 PyThreadState* __tstate = wxPyBeginAllowThreads();
11345 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11346
11347 wxPyEndAllowThreads(__tstate);
11348 if (PyErr_Occurred()) SWIG_fail;
11349 }
11350 {
11351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11352 }
11353 return resultobj;
11354 fail:
11355 return NULL;
11356 }
11357
11358
11359 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11360 PyObject *resultobj;
11361 wxImage *arg1 = (wxImage *) 0 ;
11362 wxImage *arg2 = 0 ;
11363 byte arg3 ;
11364 byte arg4 ;
11365 byte arg5 ;
11366 bool result;
11367 PyObject * obj0 = 0 ;
11368 PyObject * obj1 = 0 ;
11369 PyObject * obj2 = 0 ;
11370 PyObject * obj3 = 0 ;
11371 PyObject * obj4 = 0 ;
11372 char *kwnames[] = {
11373 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11374 };
11375
11376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11378 if (SWIG_arg_fail(1)) SWIG_fail;
11379 {
11380 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11381 if (SWIG_arg_fail(2)) SWIG_fail;
11382 if (arg2 == NULL) {
11383 SWIG_null_ref("wxImage");
11384 }
11385 if (SWIG_arg_fail(2)) SWIG_fail;
11386 }
11387 {
11388 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11389 if (SWIG_arg_fail(3)) SWIG_fail;
11390 }
11391 {
11392 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11393 if (SWIG_arg_fail(4)) SWIG_fail;
11394 }
11395 {
11396 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11397 if (SWIG_arg_fail(5)) SWIG_fail;
11398 }
11399 {
11400 PyThreadState* __tstate = wxPyBeginAllowThreads();
11401 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11402
11403 wxPyEndAllowThreads(__tstate);
11404 if (PyErr_Occurred()) SWIG_fail;
11405 }
11406 {
11407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11408 }
11409 return resultobj;
11410 fail:
11411 return NULL;
11412 }
11413
11414
11415 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11416 PyObject *resultobj;
11417 wxString *arg1 = 0 ;
11418 bool result;
11419 bool temp1 = false ;
11420 PyObject * obj0 = 0 ;
11421 char *kwnames[] = {
11422 (char *) "name", NULL
11423 };
11424
11425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11426 {
11427 arg1 = wxString_in_helper(obj0);
11428 if (arg1 == NULL) SWIG_fail;
11429 temp1 = true;
11430 }
11431 {
11432 PyThreadState* __tstate = wxPyBeginAllowThreads();
11433 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11434
11435 wxPyEndAllowThreads(__tstate);
11436 if (PyErr_Occurred()) SWIG_fail;
11437 }
11438 {
11439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11440 }
11441 {
11442 if (temp1)
11443 delete arg1;
11444 }
11445 return resultobj;
11446 fail:
11447 {
11448 if (temp1)
11449 delete arg1;
11450 }
11451 return NULL;
11452 }
11453
11454
11455 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11456 PyObject *resultobj;
11457 wxString *arg1 = 0 ;
11458 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11459 int result;
11460 bool temp1 = false ;
11461 PyObject * obj0 = 0 ;
11462 PyObject * obj1 = 0 ;
11463 char *kwnames[] = {
11464 (char *) "name",(char *) "type", NULL
11465 };
11466
11467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11468 {
11469 arg1 = wxString_in_helper(obj0);
11470 if (arg1 == NULL) SWIG_fail;
11471 temp1 = true;
11472 }
11473 if (obj1) {
11474 {
11475 arg2 = (long)(SWIG_As_long(obj1));
11476 if (SWIG_arg_fail(2)) SWIG_fail;
11477 }
11478 }
11479 {
11480 PyThreadState* __tstate = wxPyBeginAllowThreads();
11481 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11482
11483 wxPyEndAllowThreads(__tstate);
11484 if (PyErr_Occurred()) SWIG_fail;
11485 }
11486 {
11487 resultobj = SWIG_From_int((int)(result));
11488 }
11489 {
11490 if (temp1)
11491 delete arg1;
11492 }
11493 return resultobj;
11494 fail:
11495 {
11496 if (temp1)
11497 delete arg1;
11498 }
11499 return NULL;
11500 }
11501
11502
11503 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11504 PyObject *resultobj;
11505 wxImage *arg1 = (wxImage *) 0 ;
11506 wxString *arg2 = 0 ;
11507 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11508 int arg4 = (int) -1 ;
11509 bool result;
11510 bool temp2 = false ;
11511 PyObject * obj0 = 0 ;
11512 PyObject * obj1 = 0 ;
11513 PyObject * obj2 = 0 ;
11514 PyObject * obj3 = 0 ;
11515 char *kwnames[] = {
11516 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11517 };
11518
11519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11521 if (SWIG_arg_fail(1)) SWIG_fail;
11522 {
11523 arg2 = wxString_in_helper(obj1);
11524 if (arg2 == NULL) SWIG_fail;
11525 temp2 = true;
11526 }
11527 if (obj2) {
11528 {
11529 arg3 = (long)(SWIG_As_long(obj2));
11530 if (SWIG_arg_fail(3)) SWIG_fail;
11531 }
11532 }
11533 if (obj3) {
11534 {
11535 arg4 = (int)(SWIG_As_int(obj3));
11536 if (SWIG_arg_fail(4)) SWIG_fail;
11537 }
11538 }
11539 {
11540 PyThreadState* __tstate = wxPyBeginAllowThreads();
11541 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11542
11543 wxPyEndAllowThreads(__tstate);
11544 if (PyErr_Occurred()) SWIG_fail;
11545 }
11546 {
11547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11548 }
11549 {
11550 if (temp2)
11551 delete arg2;
11552 }
11553 return resultobj;
11554 fail:
11555 {
11556 if (temp2)
11557 delete arg2;
11558 }
11559 return NULL;
11560 }
11561
11562
11563 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11564 PyObject *resultobj;
11565 wxImage *arg1 = (wxImage *) 0 ;
11566 wxString *arg2 = 0 ;
11567 wxString *arg3 = 0 ;
11568 int arg4 = (int) -1 ;
11569 bool result;
11570 bool temp2 = false ;
11571 bool temp3 = false ;
11572 PyObject * obj0 = 0 ;
11573 PyObject * obj1 = 0 ;
11574 PyObject * obj2 = 0 ;
11575 PyObject * obj3 = 0 ;
11576 char *kwnames[] = {
11577 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11578 };
11579
11580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11582 if (SWIG_arg_fail(1)) SWIG_fail;
11583 {
11584 arg2 = wxString_in_helper(obj1);
11585 if (arg2 == NULL) SWIG_fail;
11586 temp2 = true;
11587 }
11588 {
11589 arg3 = wxString_in_helper(obj2);
11590 if (arg3 == NULL) SWIG_fail;
11591 temp3 = true;
11592 }
11593 if (obj3) {
11594 {
11595 arg4 = (int)(SWIG_As_int(obj3));
11596 if (SWIG_arg_fail(4)) SWIG_fail;
11597 }
11598 }
11599 {
11600 PyThreadState* __tstate = wxPyBeginAllowThreads();
11601 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11602
11603 wxPyEndAllowThreads(__tstate);
11604 if (PyErr_Occurred()) SWIG_fail;
11605 }
11606 {
11607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11608 }
11609 {
11610 if (temp2)
11611 delete arg2;
11612 }
11613 {
11614 if (temp3)
11615 delete arg3;
11616 }
11617 return resultobj;
11618 fail:
11619 {
11620 if (temp2)
11621 delete arg2;
11622 }
11623 {
11624 if (temp3)
11625 delete arg3;
11626 }
11627 return NULL;
11628 }
11629
11630
11631 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11632 PyObject *resultobj;
11633 wxImage *arg1 = (wxImage *) 0 ;
11634 wxString *arg2 = 0 ;
11635 int arg3 ;
11636 bool result;
11637 bool temp2 = false ;
11638 PyObject * obj0 = 0 ;
11639 PyObject * obj1 = 0 ;
11640 PyObject * obj2 = 0 ;
11641 char *kwnames[] = {
11642 (char *) "self",(char *) "name",(char *) "type", NULL
11643 };
11644
11645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11647 if (SWIG_arg_fail(1)) SWIG_fail;
11648 {
11649 arg2 = wxString_in_helper(obj1);
11650 if (arg2 == NULL) SWIG_fail;
11651 temp2 = true;
11652 }
11653 {
11654 arg3 = (int)(SWIG_As_int(obj2));
11655 if (SWIG_arg_fail(3)) SWIG_fail;
11656 }
11657 {
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11660
11661 wxPyEndAllowThreads(__tstate);
11662 if (PyErr_Occurred()) SWIG_fail;
11663 }
11664 {
11665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11666 }
11667 {
11668 if (temp2)
11669 delete arg2;
11670 }
11671 return resultobj;
11672 fail:
11673 {
11674 if (temp2)
11675 delete arg2;
11676 }
11677 return NULL;
11678 }
11679
11680
11681 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11682 PyObject *resultobj;
11683 wxImage *arg1 = (wxImage *) 0 ;
11684 wxString *arg2 = 0 ;
11685 wxString *arg3 = 0 ;
11686 bool result;
11687 bool temp2 = false ;
11688 bool temp3 = false ;
11689 PyObject * obj0 = 0 ;
11690 PyObject * obj1 = 0 ;
11691 PyObject * obj2 = 0 ;
11692 char *kwnames[] = {
11693 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11694 };
11695
11696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11698 if (SWIG_arg_fail(1)) SWIG_fail;
11699 {
11700 arg2 = wxString_in_helper(obj1);
11701 if (arg2 == NULL) SWIG_fail;
11702 temp2 = true;
11703 }
11704 {
11705 arg3 = wxString_in_helper(obj2);
11706 if (arg3 == NULL) SWIG_fail;
11707 temp3 = true;
11708 }
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11712
11713 wxPyEndAllowThreads(__tstate);
11714 if (PyErr_Occurred()) SWIG_fail;
11715 }
11716 {
11717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11718 }
11719 {
11720 if (temp2)
11721 delete arg2;
11722 }
11723 {
11724 if (temp3)
11725 delete arg3;
11726 }
11727 return resultobj;
11728 fail:
11729 {
11730 if (temp2)
11731 delete arg2;
11732 }
11733 {
11734 if (temp3)
11735 delete arg3;
11736 }
11737 return NULL;
11738 }
11739
11740
11741 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11742 PyObject *resultobj;
11743 wxInputStream *arg1 = 0 ;
11744 bool result;
11745 wxPyInputStream *temp1 ;
11746 bool created1 ;
11747 PyObject * obj0 = 0 ;
11748 char *kwnames[] = {
11749 (char *) "stream", NULL
11750 };
11751
11752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11753 {
11754 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11755 arg1 = temp1->m_wxis;
11756 created1 = false;
11757 } else {
11758 PyErr_Clear(); // clear the failure of the wxPyConvert above
11759 arg1 = wxPyCBInputStream_create(obj0, false);
11760 if (arg1 == NULL) {
11761 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11762 SWIG_fail;
11763 }
11764 created1 = true;
11765 }
11766 }
11767 {
11768 PyThreadState* __tstate = wxPyBeginAllowThreads();
11769 result = (bool)wxImage::CanRead(*arg1);
11770
11771 wxPyEndAllowThreads(__tstate);
11772 if (PyErr_Occurred()) SWIG_fail;
11773 }
11774 {
11775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11776 }
11777 {
11778 if (created1)
11779 delete arg1;
11780 }
11781 return resultobj;
11782 fail:
11783 {
11784 if (created1)
11785 delete arg1;
11786 }
11787 return NULL;
11788 }
11789
11790
11791 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11792 PyObject *resultobj;
11793 wxImage *arg1 = (wxImage *) 0 ;
11794 wxInputStream *arg2 = 0 ;
11795 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11796 int arg4 = (int) -1 ;
11797 bool result;
11798 wxPyInputStream *temp2 ;
11799 bool created2 ;
11800 PyObject * obj0 = 0 ;
11801 PyObject * obj1 = 0 ;
11802 PyObject * obj2 = 0 ;
11803 PyObject * obj3 = 0 ;
11804 char *kwnames[] = {
11805 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11806 };
11807
11808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11810 if (SWIG_arg_fail(1)) SWIG_fail;
11811 {
11812 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11813 arg2 = temp2->m_wxis;
11814 created2 = false;
11815 } else {
11816 PyErr_Clear(); // clear the failure of the wxPyConvert above
11817 arg2 = wxPyCBInputStream_create(obj1, false);
11818 if (arg2 == NULL) {
11819 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11820 SWIG_fail;
11821 }
11822 created2 = true;
11823 }
11824 }
11825 if (obj2) {
11826 {
11827 arg3 = (long)(SWIG_As_long(obj2));
11828 if (SWIG_arg_fail(3)) SWIG_fail;
11829 }
11830 }
11831 if (obj3) {
11832 {
11833 arg4 = (int)(SWIG_As_int(obj3));
11834 if (SWIG_arg_fail(4)) SWIG_fail;
11835 }
11836 }
11837 {
11838 PyThreadState* __tstate = wxPyBeginAllowThreads();
11839 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11840
11841 wxPyEndAllowThreads(__tstate);
11842 if (PyErr_Occurred()) SWIG_fail;
11843 }
11844 {
11845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11846 }
11847 {
11848 if (created2)
11849 delete arg2;
11850 }
11851 return resultobj;
11852 fail:
11853 {
11854 if (created2)
11855 delete arg2;
11856 }
11857 return NULL;
11858 }
11859
11860
11861 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11862 PyObject *resultobj;
11863 wxImage *arg1 = (wxImage *) 0 ;
11864 wxInputStream *arg2 = 0 ;
11865 wxString *arg3 = 0 ;
11866 int arg4 = (int) -1 ;
11867 bool result;
11868 wxPyInputStream *temp2 ;
11869 bool created2 ;
11870 bool temp3 = false ;
11871 PyObject * obj0 = 0 ;
11872 PyObject * obj1 = 0 ;
11873 PyObject * obj2 = 0 ;
11874 PyObject * obj3 = 0 ;
11875 char *kwnames[] = {
11876 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11877 };
11878
11879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11881 if (SWIG_arg_fail(1)) SWIG_fail;
11882 {
11883 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11884 arg2 = temp2->m_wxis;
11885 created2 = false;
11886 } else {
11887 PyErr_Clear(); // clear the failure of the wxPyConvert above
11888 arg2 = wxPyCBInputStream_create(obj1, false);
11889 if (arg2 == NULL) {
11890 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11891 SWIG_fail;
11892 }
11893 created2 = true;
11894 }
11895 }
11896 {
11897 arg3 = wxString_in_helper(obj2);
11898 if (arg3 == NULL) SWIG_fail;
11899 temp3 = true;
11900 }
11901 if (obj3) {
11902 {
11903 arg4 = (int)(SWIG_As_int(obj3));
11904 if (SWIG_arg_fail(4)) SWIG_fail;
11905 }
11906 }
11907 {
11908 PyThreadState* __tstate = wxPyBeginAllowThreads();
11909 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11910
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 {
11915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11916 }
11917 {
11918 if (created2)
11919 delete arg2;
11920 }
11921 {
11922 if (temp3)
11923 delete arg3;
11924 }
11925 return resultobj;
11926 fail:
11927 {
11928 if (created2)
11929 delete arg2;
11930 }
11931 {
11932 if (temp3)
11933 delete arg3;
11934 }
11935 return NULL;
11936 }
11937
11938
11939 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11940 PyObject *resultobj;
11941 wxImage *arg1 = (wxImage *) 0 ;
11942 bool result;
11943 PyObject * obj0 = 0 ;
11944 char *kwnames[] = {
11945 (char *) "self", NULL
11946 };
11947
11948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11950 if (SWIG_arg_fail(1)) SWIG_fail;
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (bool)(arg1)->Ok();
11954
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 {
11959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11960 }
11961 return resultobj;
11962 fail:
11963 return NULL;
11964 }
11965
11966
11967 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11968 PyObject *resultobj;
11969 wxImage *arg1 = (wxImage *) 0 ;
11970 int result;
11971 PyObject * obj0 = 0 ;
11972 char *kwnames[] = {
11973 (char *) "self", NULL
11974 };
11975
11976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
11977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11978 if (SWIG_arg_fail(1)) SWIG_fail;
11979 {
11980 PyThreadState* __tstate = wxPyBeginAllowThreads();
11981 result = (int)(arg1)->GetWidth();
11982
11983 wxPyEndAllowThreads(__tstate);
11984 if (PyErr_Occurred()) SWIG_fail;
11985 }
11986 {
11987 resultobj = SWIG_From_int((int)(result));
11988 }
11989 return resultobj;
11990 fail:
11991 return NULL;
11992 }
11993
11994
11995 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
11996 PyObject *resultobj;
11997 wxImage *arg1 = (wxImage *) 0 ;
11998 int result;
11999 PyObject * obj0 = 0 ;
12000 char *kwnames[] = {
12001 (char *) "self", NULL
12002 };
12003
12004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12006 if (SWIG_arg_fail(1)) SWIG_fail;
12007 {
12008 PyThreadState* __tstate = wxPyBeginAllowThreads();
12009 result = (int)(arg1)->GetHeight();
12010
12011 wxPyEndAllowThreads(__tstate);
12012 if (PyErr_Occurred()) SWIG_fail;
12013 }
12014 {
12015 resultobj = SWIG_From_int((int)(result));
12016 }
12017 return resultobj;
12018 fail:
12019 return NULL;
12020 }
12021
12022
12023 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12024 PyObject *resultobj;
12025 wxImage *arg1 = (wxImage *) 0 ;
12026 wxSize result;
12027 PyObject * obj0 = 0 ;
12028 char *kwnames[] = {
12029 (char *) "self", NULL
12030 };
12031
12032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12034 if (SWIG_arg_fail(1)) SWIG_fail;
12035 {
12036 PyThreadState* __tstate = wxPyBeginAllowThreads();
12037 result = wxImage_GetSize(arg1);
12038
12039 wxPyEndAllowThreads(__tstate);
12040 if (PyErr_Occurred()) SWIG_fail;
12041 }
12042 {
12043 wxSize * resultptr;
12044 resultptr = new wxSize((wxSize &)(result));
12045 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12046 }
12047 return resultobj;
12048 fail:
12049 return NULL;
12050 }
12051
12052
12053 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12054 PyObject *resultobj;
12055 wxImage *arg1 = (wxImage *) 0 ;
12056 wxRect *arg2 = 0 ;
12057 SwigValueWrapper<wxImage > result;
12058 wxRect temp2 ;
12059 PyObject * obj0 = 0 ;
12060 PyObject * obj1 = 0 ;
12061 char *kwnames[] = {
12062 (char *) "self",(char *) "rect", NULL
12063 };
12064
12065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12067 if (SWIG_arg_fail(1)) SWIG_fail;
12068 {
12069 arg2 = &temp2;
12070 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12071 }
12072 {
12073 PyThreadState* __tstate = wxPyBeginAllowThreads();
12074 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12075
12076 wxPyEndAllowThreads(__tstate);
12077 if (PyErr_Occurred()) SWIG_fail;
12078 }
12079 {
12080 wxImage * resultptr;
12081 resultptr = new wxImage((wxImage &)(result));
12082 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12083 }
12084 return resultobj;
12085 fail:
12086 return NULL;
12087 }
12088
12089
12090 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12091 PyObject *resultobj;
12092 wxImage *arg1 = (wxImage *) 0 ;
12093 SwigValueWrapper<wxImage > result;
12094 PyObject * obj0 = 0 ;
12095 char *kwnames[] = {
12096 (char *) "self", NULL
12097 };
12098
12099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12101 if (SWIG_arg_fail(1)) SWIG_fail;
12102 {
12103 PyThreadState* __tstate = wxPyBeginAllowThreads();
12104 result = (arg1)->Copy();
12105
12106 wxPyEndAllowThreads(__tstate);
12107 if (PyErr_Occurred()) SWIG_fail;
12108 }
12109 {
12110 wxImage * resultptr;
12111 resultptr = new wxImage((wxImage &)(result));
12112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12113 }
12114 return resultobj;
12115 fail:
12116 return NULL;
12117 }
12118
12119
12120 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12121 PyObject *resultobj;
12122 wxImage *arg1 = (wxImage *) 0 ;
12123 wxImage *arg2 = 0 ;
12124 int arg3 ;
12125 int arg4 ;
12126 PyObject * obj0 = 0 ;
12127 PyObject * obj1 = 0 ;
12128 PyObject * obj2 = 0 ;
12129 PyObject * obj3 = 0 ;
12130 char *kwnames[] = {
12131 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12132 };
12133
12134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12136 if (SWIG_arg_fail(1)) SWIG_fail;
12137 {
12138 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12139 if (SWIG_arg_fail(2)) SWIG_fail;
12140 if (arg2 == NULL) {
12141 SWIG_null_ref("wxImage");
12142 }
12143 if (SWIG_arg_fail(2)) SWIG_fail;
12144 }
12145 {
12146 arg3 = (int)(SWIG_As_int(obj2));
12147 if (SWIG_arg_fail(3)) SWIG_fail;
12148 }
12149 {
12150 arg4 = (int)(SWIG_As_int(obj3));
12151 if (SWIG_arg_fail(4)) SWIG_fail;
12152 }
12153 {
12154 PyThreadState* __tstate = wxPyBeginAllowThreads();
12155 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12156
12157 wxPyEndAllowThreads(__tstate);
12158 if (PyErr_Occurred()) SWIG_fail;
12159 }
12160 Py_INCREF(Py_None); resultobj = Py_None;
12161 return resultobj;
12162 fail:
12163 return NULL;
12164 }
12165
12166
12167 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12168 PyObject *resultobj;
12169 wxImage *arg1 = (wxImage *) 0 ;
12170 PyObject *result;
12171 PyObject * obj0 = 0 ;
12172 char *kwnames[] = {
12173 (char *) "self", NULL
12174 };
12175
12176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12178 if (SWIG_arg_fail(1)) SWIG_fail;
12179 {
12180 PyThreadState* __tstate = wxPyBeginAllowThreads();
12181 result = (PyObject *)wxImage_GetData(arg1);
12182
12183 wxPyEndAllowThreads(__tstate);
12184 if (PyErr_Occurred()) SWIG_fail;
12185 }
12186 resultobj = result;
12187 return resultobj;
12188 fail:
12189 return NULL;
12190 }
12191
12192
12193 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12194 PyObject *resultobj;
12195 wxImage *arg1 = (wxImage *) 0 ;
12196 PyObject *arg2 = (PyObject *) 0 ;
12197 PyObject * obj0 = 0 ;
12198 PyObject * obj1 = 0 ;
12199 char *kwnames[] = {
12200 (char *) "self",(char *) "data", NULL
12201 };
12202
12203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12205 if (SWIG_arg_fail(1)) SWIG_fail;
12206 arg2 = obj1;
12207 {
12208 PyThreadState* __tstate = wxPyBeginAllowThreads();
12209 wxImage_SetData(arg1,arg2);
12210
12211 wxPyEndAllowThreads(__tstate);
12212 if (PyErr_Occurred()) SWIG_fail;
12213 }
12214 Py_INCREF(Py_None); resultobj = Py_None;
12215 return resultobj;
12216 fail:
12217 return NULL;
12218 }
12219
12220
12221 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12222 PyObject *resultobj;
12223 wxImage *arg1 = (wxImage *) 0 ;
12224 PyObject *result;
12225 PyObject * obj0 = 0 ;
12226 char *kwnames[] = {
12227 (char *) "self", NULL
12228 };
12229
12230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12232 if (SWIG_arg_fail(1)) SWIG_fail;
12233 {
12234 PyThreadState* __tstate = wxPyBeginAllowThreads();
12235 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12236
12237 wxPyEndAllowThreads(__tstate);
12238 if (PyErr_Occurred()) SWIG_fail;
12239 }
12240 resultobj = result;
12241 return resultobj;
12242 fail:
12243 return NULL;
12244 }
12245
12246
12247 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12248 PyObject *resultobj;
12249 wxImage *arg1 = (wxImage *) 0 ;
12250 PyObject *arg2 = (PyObject *) 0 ;
12251 PyObject * obj0 = 0 ;
12252 PyObject * obj1 = 0 ;
12253 char *kwnames[] = {
12254 (char *) "self",(char *) "data", NULL
12255 };
12256
12257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12259 if (SWIG_arg_fail(1)) SWIG_fail;
12260 arg2 = obj1;
12261 {
12262 PyThreadState* __tstate = wxPyBeginAllowThreads();
12263 wxImage_SetDataBuffer(arg1,arg2);
12264
12265 wxPyEndAllowThreads(__tstate);
12266 if (PyErr_Occurred()) SWIG_fail;
12267 }
12268 Py_INCREF(Py_None); resultobj = Py_None;
12269 return resultobj;
12270 fail:
12271 return NULL;
12272 }
12273
12274
12275 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12276 PyObject *resultobj;
12277 wxImage *arg1 = (wxImage *) 0 ;
12278 PyObject *result;
12279 PyObject * obj0 = 0 ;
12280 char *kwnames[] = {
12281 (char *) "self", NULL
12282 };
12283
12284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12286 if (SWIG_arg_fail(1)) SWIG_fail;
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 result = (PyObject *)wxImage_GetAlphaData(arg1);
12290
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 resultobj = result;
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12302 PyObject *resultobj;
12303 wxImage *arg1 = (wxImage *) 0 ;
12304 PyObject *arg2 = (PyObject *) 0 ;
12305 PyObject * obj0 = 0 ;
12306 PyObject * obj1 = 0 ;
12307 char *kwnames[] = {
12308 (char *) "self",(char *) "data", NULL
12309 };
12310
12311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12313 if (SWIG_arg_fail(1)) SWIG_fail;
12314 arg2 = obj1;
12315 {
12316 PyThreadState* __tstate = wxPyBeginAllowThreads();
12317 wxImage_SetAlphaData(arg1,arg2);
12318
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 Py_INCREF(Py_None); resultobj = Py_None;
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12330 PyObject *resultobj;
12331 wxImage *arg1 = (wxImage *) 0 ;
12332 PyObject *result;
12333 PyObject * obj0 = 0 ;
12334 char *kwnames[] = {
12335 (char *) "self", NULL
12336 };
12337
12338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12340 if (SWIG_arg_fail(1)) SWIG_fail;
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12344
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 resultobj = result;
12349 return resultobj;
12350 fail:
12351 return NULL;
12352 }
12353
12354
12355 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12356 PyObject *resultobj;
12357 wxImage *arg1 = (wxImage *) 0 ;
12358 PyObject *arg2 = (PyObject *) 0 ;
12359 PyObject * obj0 = 0 ;
12360 PyObject * obj1 = 0 ;
12361 char *kwnames[] = {
12362 (char *) "self",(char *) "data", NULL
12363 };
12364
12365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12367 if (SWIG_arg_fail(1)) SWIG_fail;
12368 arg2 = obj1;
12369 {
12370 PyThreadState* __tstate = wxPyBeginAllowThreads();
12371 wxImage_SetAlphaBuffer(arg1,arg2);
12372
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 Py_INCREF(Py_None); resultobj = Py_None;
12377 return resultobj;
12378 fail:
12379 return NULL;
12380 }
12381
12382
12383 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12384 PyObject *resultobj;
12385 wxImage *arg1 = (wxImage *) 0 ;
12386 unsigned char arg2 ;
12387 unsigned char arg3 ;
12388 unsigned char arg4 ;
12389 PyObject * obj0 = 0 ;
12390 PyObject * obj1 = 0 ;
12391 PyObject * obj2 = 0 ;
12392 PyObject * obj3 = 0 ;
12393 char *kwnames[] = {
12394 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12395 };
12396
12397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12399 if (SWIG_arg_fail(1)) SWIG_fail;
12400 {
12401 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12402 if (SWIG_arg_fail(2)) SWIG_fail;
12403 }
12404 {
12405 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12406 if (SWIG_arg_fail(3)) SWIG_fail;
12407 }
12408 {
12409 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12410 if (SWIG_arg_fail(4)) SWIG_fail;
12411 }
12412 {
12413 PyThreadState* __tstate = wxPyBeginAllowThreads();
12414 (arg1)->SetMaskColour(arg2,arg3,arg4);
12415
12416 wxPyEndAllowThreads(__tstate);
12417 if (PyErr_Occurred()) SWIG_fail;
12418 }
12419 Py_INCREF(Py_None); resultobj = Py_None;
12420 return resultobj;
12421 fail:
12422 return NULL;
12423 }
12424
12425
12426 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12427 PyObject *resultobj;
12428 wxImage *arg1 = (wxImage *) 0 ;
12429 unsigned char result;
12430 PyObject * obj0 = 0 ;
12431 char *kwnames[] = {
12432 (char *) "self", NULL
12433 };
12434
12435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12437 if (SWIG_arg_fail(1)) SWIG_fail;
12438 {
12439 PyThreadState* __tstate = wxPyBeginAllowThreads();
12440 result = (unsigned char)(arg1)->GetMaskRed();
12441
12442 wxPyEndAllowThreads(__tstate);
12443 if (PyErr_Occurred()) SWIG_fail;
12444 }
12445 {
12446 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12447 }
12448 return resultobj;
12449 fail:
12450 return NULL;
12451 }
12452
12453
12454 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12455 PyObject *resultobj;
12456 wxImage *arg1 = (wxImage *) 0 ;
12457 unsigned char result;
12458 PyObject * obj0 = 0 ;
12459 char *kwnames[] = {
12460 (char *) "self", NULL
12461 };
12462
12463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12465 if (SWIG_arg_fail(1)) SWIG_fail;
12466 {
12467 PyThreadState* __tstate = wxPyBeginAllowThreads();
12468 result = (unsigned char)(arg1)->GetMaskGreen();
12469
12470 wxPyEndAllowThreads(__tstate);
12471 if (PyErr_Occurred()) SWIG_fail;
12472 }
12473 {
12474 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12475 }
12476 return resultobj;
12477 fail:
12478 return NULL;
12479 }
12480
12481
12482 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12483 PyObject *resultobj;
12484 wxImage *arg1 = (wxImage *) 0 ;
12485 unsigned char result;
12486 PyObject * obj0 = 0 ;
12487 char *kwnames[] = {
12488 (char *) "self", NULL
12489 };
12490
12491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12493 if (SWIG_arg_fail(1)) SWIG_fail;
12494 {
12495 PyThreadState* __tstate = wxPyBeginAllowThreads();
12496 result = (unsigned char)(arg1)->GetMaskBlue();
12497
12498 wxPyEndAllowThreads(__tstate);
12499 if (PyErr_Occurred()) SWIG_fail;
12500 }
12501 {
12502 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12503 }
12504 return resultobj;
12505 fail:
12506 return NULL;
12507 }
12508
12509
12510 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12511 PyObject *resultobj;
12512 wxImage *arg1 = (wxImage *) 0 ;
12513 bool arg2 = (bool) true ;
12514 PyObject * obj0 = 0 ;
12515 PyObject * obj1 = 0 ;
12516 char *kwnames[] = {
12517 (char *) "self",(char *) "mask", NULL
12518 };
12519
12520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12522 if (SWIG_arg_fail(1)) SWIG_fail;
12523 if (obj1) {
12524 {
12525 arg2 = (bool)(SWIG_As_bool(obj1));
12526 if (SWIG_arg_fail(2)) SWIG_fail;
12527 }
12528 }
12529 {
12530 PyThreadState* __tstate = wxPyBeginAllowThreads();
12531 (arg1)->SetMask(arg2);
12532
12533 wxPyEndAllowThreads(__tstate);
12534 if (PyErr_Occurred()) SWIG_fail;
12535 }
12536 Py_INCREF(Py_None); resultobj = Py_None;
12537 return resultobj;
12538 fail:
12539 return NULL;
12540 }
12541
12542
12543 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12544 PyObject *resultobj;
12545 wxImage *arg1 = (wxImage *) 0 ;
12546 bool result;
12547 PyObject * obj0 = 0 ;
12548 char *kwnames[] = {
12549 (char *) "self", NULL
12550 };
12551
12552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12554 if (SWIG_arg_fail(1)) SWIG_fail;
12555 {
12556 PyThreadState* __tstate = wxPyBeginAllowThreads();
12557 result = (bool)(arg1)->HasMask();
12558
12559 wxPyEndAllowThreads(__tstate);
12560 if (PyErr_Occurred()) SWIG_fail;
12561 }
12562 {
12563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12564 }
12565 return resultobj;
12566 fail:
12567 return NULL;
12568 }
12569
12570
12571 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12572 PyObject *resultobj;
12573 wxImage *arg1 = (wxImage *) 0 ;
12574 double arg2 ;
12575 wxPoint *arg3 = 0 ;
12576 bool arg4 = (bool) true ;
12577 wxPoint *arg5 = (wxPoint *) NULL ;
12578 SwigValueWrapper<wxImage > result;
12579 wxPoint temp3 ;
12580 PyObject * obj0 = 0 ;
12581 PyObject * obj1 = 0 ;
12582 PyObject * obj2 = 0 ;
12583 PyObject * obj3 = 0 ;
12584 PyObject * obj4 = 0 ;
12585 char *kwnames[] = {
12586 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12587 };
12588
12589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12591 if (SWIG_arg_fail(1)) SWIG_fail;
12592 {
12593 arg2 = (double)(SWIG_As_double(obj1));
12594 if (SWIG_arg_fail(2)) SWIG_fail;
12595 }
12596 {
12597 arg3 = &temp3;
12598 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12599 }
12600 if (obj3) {
12601 {
12602 arg4 = (bool)(SWIG_As_bool(obj3));
12603 if (SWIG_arg_fail(4)) SWIG_fail;
12604 }
12605 }
12606 if (obj4) {
12607 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12608 if (SWIG_arg_fail(5)) SWIG_fail;
12609 }
12610 {
12611 PyThreadState* __tstate = wxPyBeginAllowThreads();
12612 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12613
12614 wxPyEndAllowThreads(__tstate);
12615 if (PyErr_Occurred()) SWIG_fail;
12616 }
12617 {
12618 wxImage * resultptr;
12619 resultptr = new wxImage((wxImage &)(result));
12620 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12621 }
12622 return resultobj;
12623 fail:
12624 return NULL;
12625 }
12626
12627
12628 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12629 PyObject *resultobj;
12630 wxImage *arg1 = (wxImage *) 0 ;
12631 bool arg2 = (bool) true ;
12632 SwigValueWrapper<wxImage > result;
12633 PyObject * obj0 = 0 ;
12634 PyObject * obj1 = 0 ;
12635 char *kwnames[] = {
12636 (char *) "self",(char *) "clockwise", NULL
12637 };
12638
12639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12641 if (SWIG_arg_fail(1)) SWIG_fail;
12642 if (obj1) {
12643 {
12644 arg2 = (bool)(SWIG_As_bool(obj1));
12645 if (SWIG_arg_fail(2)) SWIG_fail;
12646 }
12647 }
12648 {
12649 PyThreadState* __tstate = wxPyBeginAllowThreads();
12650 result = (arg1)->Rotate90(arg2);
12651
12652 wxPyEndAllowThreads(__tstate);
12653 if (PyErr_Occurred()) SWIG_fail;
12654 }
12655 {
12656 wxImage * resultptr;
12657 resultptr = new wxImage((wxImage &)(result));
12658 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12659 }
12660 return resultobj;
12661 fail:
12662 return NULL;
12663 }
12664
12665
12666 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12667 PyObject *resultobj;
12668 wxImage *arg1 = (wxImage *) 0 ;
12669 bool arg2 = (bool) true ;
12670 SwigValueWrapper<wxImage > result;
12671 PyObject * obj0 = 0 ;
12672 PyObject * obj1 = 0 ;
12673 char *kwnames[] = {
12674 (char *) "self",(char *) "horizontally", NULL
12675 };
12676
12677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12679 if (SWIG_arg_fail(1)) SWIG_fail;
12680 if (obj1) {
12681 {
12682 arg2 = (bool)(SWIG_As_bool(obj1));
12683 if (SWIG_arg_fail(2)) SWIG_fail;
12684 }
12685 }
12686 {
12687 PyThreadState* __tstate = wxPyBeginAllowThreads();
12688 result = (arg1)->Mirror(arg2);
12689
12690 wxPyEndAllowThreads(__tstate);
12691 if (PyErr_Occurred()) SWIG_fail;
12692 }
12693 {
12694 wxImage * resultptr;
12695 resultptr = new wxImage((wxImage &)(result));
12696 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12697 }
12698 return resultobj;
12699 fail:
12700 return NULL;
12701 }
12702
12703
12704 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12705 PyObject *resultobj;
12706 wxImage *arg1 = (wxImage *) 0 ;
12707 unsigned char arg2 ;
12708 unsigned char arg3 ;
12709 unsigned char arg4 ;
12710 unsigned char arg5 ;
12711 unsigned char arg6 ;
12712 unsigned char arg7 ;
12713 PyObject * obj0 = 0 ;
12714 PyObject * obj1 = 0 ;
12715 PyObject * obj2 = 0 ;
12716 PyObject * obj3 = 0 ;
12717 PyObject * obj4 = 0 ;
12718 PyObject * obj5 = 0 ;
12719 PyObject * obj6 = 0 ;
12720 char *kwnames[] = {
12721 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12722 };
12723
12724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12726 if (SWIG_arg_fail(1)) SWIG_fail;
12727 {
12728 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12729 if (SWIG_arg_fail(2)) SWIG_fail;
12730 }
12731 {
12732 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12733 if (SWIG_arg_fail(3)) SWIG_fail;
12734 }
12735 {
12736 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12737 if (SWIG_arg_fail(4)) SWIG_fail;
12738 }
12739 {
12740 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12741 if (SWIG_arg_fail(5)) SWIG_fail;
12742 }
12743 {
12744 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12745 if (SWIG_arg_fail(6)) SWIG_fail;
12746 }
12747 {
12748 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12749 if (SWIG_arg_fail(7)) SWIG_fail;
12750 }
12751 {
12752 PyThreadState* __tstate = wxPyBeginAllowThreads();
12753 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12754
12755 wxPyEndAllowThreads(__tstate);
12756 if (PyErr_Occurred()) SWIG_fail;
12757 }
12758 Py_INCREF(Py_None); resultobj = Py_None;
12759 return resultobj;
12760 fail:
12761 return NULL;
12762 }
12763
12764
12765 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12766 PyObject *resultobj;
12767 wxImage *arg1 = (wxImage *) 0 ;
12768 unsigned char arg2 ;
12769 unsigned char arg3 ;
12770 unsigned char arg4 ;
12771 SwigValueWrapper<wxImage > result;
12772 PyObject * obj0 = 0 ;
12773 PyObject * obj1 = 0 ;
12774 PyObject * obj2 = 0 ;
12775 PyObject * obj3 = 0 ;
12776 char *kwnames[] = {
12777 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12778 };
12779
12780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12782 if (SWIG_arg_fail(1)) SWIG_fail;
12783 {
12784 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12785 if (SWIG_arg_fail(2)) SWIG_fail;
12786 }
12787 {
12788 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12789 if (SWIG_arg_fail(3)) SWIG_fail;
12790 }
12791 {
12792 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12793 if (SWIG_arg_fail(4)) SWIG_fail;
12794 }
12795 {
12796 PyThreadState* __tstate = wxPyBeginAllowThreads();
12797 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12798
12799 wxPyEndAllowThreads(__tstate);
12800 if (PyErr_Occurred()) SWIG_fail;
12801 }
12802 {
12803 wxImage * resultptr;
12804 resultptr = new wxImage((wxImage &)(result));
12805 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12806 }
12807 return resultobj;
12808 fail:
12809 return NULL;
12810 }
12811
12812
12813 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12814 PyObject *resultobj;
12815 wxImage *arg1 = (wxImage *) 0 ;
12816 wxString *arg2 = 0 ;
12817 wxString *arg3 = 0 ;
12818 bool temp2 = false ;
12819 bool temp3 = false ;
12820 PyObject * obj0 = 0 ;
12821 PyObject * obj1 = 0 ;
12822 PyObject * obj2 = 0 ;
12823 char *kwnames[] = {
12824 (char *) "self",(char *) "name",(char *) "value", NULL
12825 };
12826
12827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12829 if (SWIG_arg_fail(1)) SWIG_fail;
12830 {
12831 arg2 = wxString_in_helper(obj1);
12832 if (arg2 == NULL) SWIG_fail;
12833 temp2 = true;
12834 }
12835 {
12836 arg3 = wxString_in_helper(obj2);
12837 if (arg3 == NULL) SWIG_fail;
12838 temp3 = true;
12839 }
12840 {
12841 PyThreadState* __tstate = wxPyBeginAllowThreads();
12842 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12843
12844 wxPyEndAllowThreads(__tstate);
12845 if (PyErr_Occurred()) SWIG_fail;
12846 }
12847 Py_INCREF(Py_None); resultobj = Py_None;
12848 {
12849 if (temp2)
12850 delete arg2;
12851 }
12852 {
12853 if (temp3)
12854 delete arg3;
12855 }
12856 return resultobj;
12857 fail:
12858 {
12859 if (temp2)
12860 delete arg2;
12861 }
12862 {
12863 if (temp3)
12864 delete arg3;
12865 }
12866 return NULL;
12867 }
12868
12869
12870 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12871 PyObject *resultobj;
12872 wxImage *arg1 = (wxImage *) 0 ;
12873 wxString *arg2 = 0 ;
12874 int arg3 ;
12875 bool temp2 = false ;
12876 PyObject * obj0 = 0 ;
12877 PyObject * obj1 = 0 ;
12878 PyObject * obj2 = 0 ;
12879 char *kwnames[] = {
12880 (char *) "self",(char *) "name",(char *) "value", NULL
12881 };
12882
12883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12885 if (SWIG_arg_fail(1)) SWIG_fail;
12886 {
12887 arg2 = wxString_in_helper(obj1);
12888 if (arg2 == NULL) SWIG_fail;
12889 temp2 = true;
12890 }
12891 {
12892 arg3 = (int)(SWIG_As_int(obj2));
12893 if (SWIG_arg_fail(3)) SWIG_fail;
12894 }
12895 {
12896 PyThreadState* __tstate = wxPyBeginAllowThreads();
12897 (arg1)->SetOption((wxString const &)*arg2,arg3);
12898
12899 wxPyEndAllowThreads(__tstate);
12900 if (PyErr_Occurred()) SWIG_fail;
12901 }
12902 Py_INCREF(Py_None); resultobj = Py_None;
12903 {
12904 if (temp2)
12905 delete arg2;
12906 }
12907 return resultobj;
12908 fail:
12909 {
12910 if (temp2)
12911 delete arg2;
12912 }
12913 return NULL;
12914 }
12915
12916
12917 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12918 PyObject *resultobj;
12919 wxImage *arg1 = (wxImage *) 0 ;
12920 wxString *arg2 = 0 ;
12921 wxString result;
12922 bool temp2 = false ;
12923 PyObject * obj0 = 0 ;
12924 PyObject * obj1 = 0 ;
12925 char *kwnames[] = {
12926 (char *) "self",(char *) "name", NULL
12927 };
12928
12929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12931 if (SWIG_arg_fail(1)) SWIG_fail;
12932 {
12933 arg2 = wxString_in_helper(obj1);
12934 if (arg2 == NULL) SWIG_fail;
12935 temp2 = true;
12936 }
12937 {
12938 PyThreadState* __tstate = wxPyBeginAllowThreads();
12939 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12940
12941 wxPyEndAllowThreads(__tstate);
12942 if (PyErr_Occurred()) SWIG_fail;
12943 }
12944 {
12945 #if wxUSE_UNICODE
12946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12947 #else
12948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12949 #endif
12950 }
12951 {
12952 if (temp2)
12953 delete arg2;
12954 }
12955 return resultobj;
12956 fail:
12957 {
12958 if (temp2)
12959 delete arg2;
12960 }
12961 return NULL;
12962 }
12963
12964
12965 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12966 PyObject *resultobj;
12967 wxImage *arg1 = (wxImage *) 0 ;
12968 wxString *arg2 = 0 ;
12969 int result;
12970 bool temp2 = false ;
12971 PyObject * obj0 = 0 ;
12972 PyObject * obj1 = 0 ;
12973 char *kwnames[] = {
12974 (char *) "self",(char *) "name", NULL
12975 };
12976
12977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
12978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12979 if (SWIG_arg_fail(1)) SWIG_fail;
12980 {
12981 arg2 = wxString_in_helper(obj1);
12982 if (arg2 == NULL) SWIG_fail;
12983 temp2 = true;
12984 }
12985 {
12986 PyThreadState* __tstate = wxPyBeginAllowThreads();
12987 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
12988
12989 wxPyEndAllowThreads(__tstate);
12990 if (PyErr_Occurred()) SWIG_fail;
12991 }
12992 {
12993 resultobj = SWIG_From_int((int)(result));
12994 }
12995 {
12996 if (temp2)
12997 delete arg2;
12998 }
12999 return resultobj;
13000 fail:
13001 {
13002 if (temp2)
13003 delete arg2;
13004 }
13005 return NULL;
13006 }
13007
13008
13009 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13010 PyObject *resultobj;
13011 wxImage *arg1 = (wxImage *) 0 ;
13012 wxString *arg2 = 0 ;
13013 bool result;
13014 bool temp2 = false ;
13015 PyObject * obj0 = 0 ;
13016 PyObject * obj1 = 0 ;
13017 char *kwnames[] = {
13018 (char *) "self",(char *) "name", NULL
13019 };
13020
13021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",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 {
13025 arg2 = wxString_in_helper(obj1);
13026 if (arg2 == NULL) SWIG_fail;
13027 temp2 = true;
13028 }
13029 {
13030 PyThreadState* __tstate = wxPyBeginAllowThreads();
13031 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13032
13033 wxPyEndAllowThreads(__tstate);
13034 if (PyErr_Occurred()) SWIG_fail;
13035 }
13036 {
13037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13038 }
13039 {
13040 if (temp2)
13041 delete arg2;
13042 }
13043 return resultobj;
13044 fail:
13045 {
13046 if (temp2)
13047 delete arg2;
13048 }
13049 return NULL;
13050 }
13051
13052
13053 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13054 PyObject *resultobj;
13055 wxImage *arg1 = (wxImage *) 0 ;
13056 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13057 unsigned long result;
13058 PyObject * obj0 = 0 ;
13059 PyObject * obj1 = 0 ;
13060 char *kwnames[] = {
13061 (char *) "self",(char *) "stopafter", NULL
13062 };
13063
13064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13066 if (SWIG_arg_fail(1)) SWIG_fail;
13067 if (obj1) {
13068 {
13069 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13070 if (SWIG_arg_fail(2)) SWIG_fail;
13071 }
13072 }
13073 {
13074 PyThreadState* __tstate = wxPyBeginAllowThreads();
13075 result = (unsigned long)(arg1)->CountColours(arg2);
13076
13077 wxPyEndAllowThreads(__tstate);
13078 if (PyErr_Occurred()) SWIG_fail;
13079 }
13080 {
13081 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13082 }
13083 return resultobj;
13084 fail:
13085 return NULL;
13086 }
13087
13088
13089 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13090 PyObject *resultobj;
13091 wxImage *arg1 = (wxImage *) 0 ;
13092 wxImageHistogram *arg2 = 0 ;
13093 unsigned long result;
13094 PyObject * obj0 = 0 ;
13095 PyObject * obj1 = 0 ;
13096 char *kwnames[] = {
13097 (char *) "self",(char *) "h", NULL
13098 };
13099
13100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13102 if (SWIG_arg_fail(1)) SWIG_fail;
13103 {
13104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13105 if (SWIG_arg_fail(2)) SWIG_fail;
13106 if (arg2 == NULL) {
13107 SWIG_null_ref("wxImageHistogram");
13108 }
13109 if (SWIG_arg_fail(2)) SWIG_fail;
13110 }
13111 {
13112 PyThreadState* __tstate = wxPyBeginAllowThreads();
13113 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13114
13115 wxPyEndAllowThreads(__tstate);
13116 if (PyErr_Occurred()) SWIG_fail;
13117 }
13118 {
13119 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13120 }
13121 return resultobj;
13122 fail:
13123 return NULL;
13124 }
13125
13126
13127 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13128 PyObject *resultobj;
13129 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13130 PyObject * obj0 = 0 ;
13131 char *kwnames[] = {
13132 (char *) "handler", NULL
13133 };
13134
13135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13137 if (SWIG_arg_fail(1)) SWIG_fail;
13138 {
13139 PyThreadState* __tstate = wxPyBeginAllowThreads();
13140 wxImage::AddHandler(arg1);
13141
13142 wxPyEndAllowThreads(__tstate);
13143 if (PyErr_Occurred()) SWIG_fail;
13144 }
13145 Py_INCREF(Py_None); resultobj = Py_None;
13146 return resultobj;
13147 fail:
13148 return NULL;
13149 }
13150
13151
13152 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13153 PyObject *resultobj;
13154 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13155 PyObject * obj0 = 0 ;
13156 char *kwnames[] = {
13157 (char *) "handler", NULL
13158 };
13159
13160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13162 if (SWIG_arg_fail(1)) SWIG_fail;
13163 {
13164 PyThreadState* __tstate = wxPyBeginAllowThreads();
13165 wxImage::InsertHandler(arg1);
13166
13167 wxPyEndAllowThreads(__tstate);
13168 if (PyErr_Occurred()) SWIG_fail;
13169 }
13170 Py_INCREF(Py_None); resultobj = Py_None;
13171 return resultobj;
13172 fail:
13173 return NULL;
13174 }
13175
13176
13177 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13178 PyObject *resultobj;
13179 wxString *arg1 = 0 ;
13180 bool result;
13181 bool temp1 = false ;
13182 PyObject * obj0 = 0 ;
13183 char *kwnames[] = {
13184 (char *) "name", NULL
13185 };
13186
13187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13188 {
13189 arg1 = wxString_in_helper(obj0);
13190 if (arg1 == NULL) SWIG_fail;
13191 temp1 = true;
13192 }
13193 {
13194 PyThreadState* __tstate = wxPyBeginAllowThreads();
13195 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13196
13197 wxPyEndAllowThreads(__tstate);
13198 if (PyErr_Occurred()) SWIG_fail;
13199 }
13200 {
13201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13202 }
13203 {
13204 if (temp1)
13205 delete arg1;
13206 }
13207 return resultobj;
13208 fail:
13209 {
13210 if (temp1)
13211 delete arg1;
13212 }
13213 return NULL;
13214 }
13215
13216
13217 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13218 PyObject *resultobj;
13219 wxString result;
13220 char *kwnames[] = {
13221 NULL
13222 };
13223
13224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13225 {
13226 PyThreadState* __tstate = wxPyBeginAllowThreads();
13227 result = wxImage::GetImageExtWildcard();
13228
13229 wxPyEndAllowThreads(__tstate);
13230 if (PyErr_Occurred()) SWIG_fail;
13231 }
13232 {
13233 #if wxUSE_UNICODE
13234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13235 #else
13236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13237 #endif
13238 }
13239 return resultobj;
13240 fail:
13241 return NULL;
13242 }
13243
13244
13245 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13246 PyObject *resultobj;
13247 wxImage *arg1 = (wxImage *) 0 ;
13248 int arg2 = (int) -1 ;
13249 wxBitmap result;
13250 PyObject * obj0 = 0 ;
13251 PyObject * obj1 = 0 ;
13252 char *kwnames[] = {
13253 (char *) "self",(char *) "depth", NULL
13254 };
13255
13256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13258 if (SWIG_arg_fail(1)) SWIG_fail;
13259 if (obj1) {
13260 {
13261 arg2 = (int)(SWIG_As_int(obj1));
13262 if (SWIG_arg_fail(2)) SWIG_fail;
13263 }
13264 }
13265 {
13266 if (!wxPyCheckForApp()) SWIG_fail;
13267 PyThreadState* __tstate = wxPyBeginAllowThreads();
13268 result = wxImage_ConvertToBitmap(arg1,arg2);
13269
13270 wxPyEndAllowThreads(__tstate);
13271 if (PyErr_Occurred()) SWIG_fail;
13272 }
13273 {
13274 wxBitmap * resultptr;
13275 resultptr = new wxBitmap((wxBitmap &)(result));
13276 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13277 }
13278 return resultobj;
13279 fail:
13280 return NULL;
13281 }
13282
13283
13284 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13285 PyObject *resultobj;
13286 wxImage *arg1 = (wxImage *) 0 ;
13287 unsigned char arg2 ;
13288 unsigned char arg3 ;
13289 unsigned char arg4 ;
13290 wxBitmap result;
13291 PyObject * obj0 = 0 ;
13292 PyObject * obj1 = 0 ;
13293 PyObject * obj2 = 0 ;
13294 PyObject * obj3 = 0 ;
13295 char *kwnames[] = {
13296 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13297 };
13298
13299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13301 if (SWIG_arg_fail(1)) SWIG_fail;
13302 {
13303 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13304 if (SWIG_arg_fail(2)) SWIG_fail;
13305 }
13306 {
13307 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13308 if (SWIG_arg_fail(3)) SWIG_fail;
13309 }
13310 {
13311 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13312 if (SWIG_arg_fail(4)) SWIG_fail;
13313 }
13314 {
13315 if (!wxPyCheckForApp()) SWIG_fail;
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13318
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 {
13323 wxBitmap * resultptr;
13324 resultptr = new wxBitmap((wxBitmap &)(result));
13325 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13326 }
13327 return resultobj;
13328 fail:
13329 return NULL;
13330 }
13331
13332
13333 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13334 PyObject *obj;
13335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13336 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13337 Py_INCREF(obj);
13338 return Py_BuildValue((char *)"");
13339 }
13340 static int _wrap_NullImage_set(PyObject *) {
13341 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13342 return 1;
13343 }
13344
13345
13346 static PyObject *_wrap_NullImage_get(void) {
13347 PyObject *pyobj;
13348
13349 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13350 return pyobj;
13351 }
13352
13353
13354 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13355 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13356 return 1;
13357 }
13358
13359
13360 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13361 PyObject *pyobj;
13362
13363 {
13364 #if wxUSE_UNICODE
13365 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13366 #else
13367 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13368 #endif
13369 }
13370 return pyobj;
13371 }
13372
13373
13374 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13375 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13376 return 1;
13377 }
13378
13379
13380 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13381 PyObject *pyobj;
13382
13383 {
13384 #if wxUSE_UNICODE
13385 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13386 #else
13387 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13388 #endif
13389 }
13390 return pyobj;
13391 }
13392
13393
13394 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13395 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13396 return 1;
13397 }
13398
13399
13400 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13401 PyObject *pyobj;
13402
13403 {
13404 #if wxUSE_UNICODE
13405 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13406 #else
13407 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13408 #endif
13409 }
13410 return pyobj;
13411 }
13412
13413
13414 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13415 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13416 return 1;
13417 }
13418
13419
13420 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13421 PyObject *pyobj;
13422
13423 {
13424 #if wxUSE_UNICODE
13425 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13426 #else
13427 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13428 #endif
13429 }
13430 return pyobj;
13431 }
13432
13433
13434 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13435 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13436 return 1;
13437 }
13438
13439
13440 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13441 PyObject *pyobj;
13442
13443 {
13444 #if wxUSE_UNICODE
13445 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13446 #else
13447 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13448 #endif
13449 }
13450 return pyobj;
13451 }
13452
13453
13454 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13455 PyObject *resultobj;
13456 wxBMPHandler *result;
13457 char *kwnames[] = {
13458 NULL
13459 };
13460
13461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13462 {
13463 PyThreadState* __tstate = wxPyBeginAllowThreads();
13464 result = (wxBMPHandler *)new wxBMPHandler();
13465
13466 wxPyEndAllowThreads(__tstate);
13467 if (PyErr_Occurred()) SWIG_fail;
13468 }
13469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13470 return resultobj;
13471 fail:
13472 return NULL;
13473 }
13474
13475
13476 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13477 PyObject *obj;
13478 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13479 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13480 Py_INCREF(obj);
13481 return Py_BuildValue((char *)"");
13482 }
13483 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13484 PyObject *resultobj;
13485 wxICOHandler *result;
13486 char *kwnames[] = {
13487 NULL
13488 };
13489
13490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13491 {
13492 PyThreadState* __tstate = wxPyBeginAllowThreads();
13493 result = (wxICOHandler *)new wxICOHandler();
13494
13495 wxPyEndAllowThreads(__tstate);
13496 if (PyErr_Occurred()) SWIG_fail;
13497 }
13498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13499 return resultobj;
13500 fail:
13501 return NULL;
13502 }
13503
13504
13505 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13506 PyObject *obj;
13507 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13508 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13509 Py_INCREF(obj);
13510 return Py_BuildValue((char *)"");
13511 }
13512 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13513 PyObject *resultobj;
13514 wxCURHandler *result;
13515 char *kwnames[] = {
13516 NULL
13517 };
13518
13519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13520 {
13521 PyThreadState* __tstate = wxPyBeginAllowThreads();
13522 result = (wxCURHandler *)new wxCURHandler();
13523
13524 wxPyEndAllowThreads(__tstate);
13525 if (PyErr_Occurred()) SWIG_fail;
13526 }
13527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13528 return resultobj;
13529 fail:
13530 return NULL;
13531 }
13532
13533
13534 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13535 PyObject *obj;
13536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13537 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13538 Py_INCREF(obj);
13539 return Py_BuildValue((char *)"");
13540 }
13541 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj;
13543 wxANIHandler *result;
13544 char *kwnames[] = {
13545 NULL
13546 };
13547
13548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13549 {
13550 PyThreadState* __tstate = wxPyBeginAllowThreads();
13551 result = (wxANIHandler *)new wxANIHandler();
13552
13553 wxPyEndAllowThreads(__tstate);
13554 if (PyErr_Occurred()) SWIG_fail;
13555 }
13556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13557 return resultobj;
13558 fail:
13559 return NULL;
13560 }
13561
13562
13563 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13564 PyObject *obj;
13565 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13566 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13567 Py_INCREF(obj);
13568 return Py_BuildValue((char *)"");
13569 }
13570 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13571 PyObject *resultobj;
13572 wxPNGHandler *result;
13573 char *kwnames[] = {
13574 NULL
13575 };
13576
13577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13578 {
13579 PyThreadState* __tstate = wxPyBeginAllowThreads();
13580 result = (wxPNGHandler *)new wxPNGHandler();
13581
13582 wxPyEndAllowThreads(__tstate);
13583 if (PyErr_Occurred()) SWIG_fail;
13584 }
13585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13586 return resultobj;
13587 fail:
13588 return NULL;
13589 }
13590
13591
13592 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13593 PyObject *obj;
13594 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13595 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13596 Py_INCREF(obj);
13597 return Py_BuildValue((char *)"");
13598 }
13599 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13600 PyObject *resultobj;
13601 wxGIFHandler *result;
13602 char *kwnames[] = {
13603 NULL
13604 };
13605
13606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13607 {
13608 PyThreadState* __tstate = wxPyBeginAllowThreads();
13609 result = (wxGIFHandler *)new wxGIFHandler();
13610
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13622 PyObject *obj;
13623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13624 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13625 Py_INCREF(obj);
13626 return Py_BuildValue((char *)"");
13627 }
13628 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13629 PyObject *resultobj;
13630 wxPCXHandler *result;
13631 char *kwnames[] = {
13632 NULL
13633 };
13634
13635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 result = (wxPCXHandler *)new wxPCXHandler();
13639
13640 wxPyEndAllowThreads(__tstate);
13641 if (PyErr_Occurred()) SWIG_fail;
13642 }
13643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13644 return resultobj;
13645 fail:
13646 return NULL;
13647 }
13648
13649
13650 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13651 PyObject *obj;
13652 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13653 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13654 Py_INCREF(obj);
13655 return Py_BuildValue((char *)"");
13656 }
13657 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13658 PyObject *resultobj;
13659 wxJPEGHandler *result;
13660 char *kwnames[] = {
13661 NULL
13662 };
13663
13664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13665 {
13666 PyThreadState* __tstate = wxPyBeginAllowThreads();
13667 result = (wxJPEGHandler *)new wxJPEGHandler();
13668
13669 wxPyEndAllowThreads(__tstate);
13670 if (PyErr_Occurred()) SWIG_fail;
13671 }
13672 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13673 return resultobj;
13674 fail:
13675 return NULL;
13676 }
13677
13678
13679 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13680 PyObject *obj;
13681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13682 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13683 Py_INCREF(obj);
13684 return Py_BuildValue((char *)"");
13685 }
13686 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13687 PyObject *resultobj;
13688 wxPNMHandler *result;
13689 char *kwnames[] = {
13690 NULL
13691 };
13692
13693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13694 {
13695 PyThreadState* __tstate = wxPyBeginAllowThreads();
13696 result = (wxPNMHandler *)new wxPNMHandler();
13697
13698 wxPyEndAllowThreads(__tstate);
13699 if (PyErr_Occurred()) SWIG_fail;
13700 }
13701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13702 return resultobj;
13703 fail:
13704 return NULL;
13705 }
13706
13707
13708 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13709 PyObject *obj;
13710 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13711 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13712 Py_INCREF(obj);
13713 return Py_BuildValue((char *)"");
13714 }
13715 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13716 PyObject *resultobj;
13717 wxXPMHandler *result;
13718 char *kwnames[] = {
13719 NULL
13720 };
13721
13722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13723 {
13724 PyThreadState* __tstate = wxPyBeginAllowThreads();
13725 result = (wxXPMHandler *)new wxXPMHandler();
13726
13727 wxPyEndAllowThreads(__tstate);
13728 if (PyErr_Occurred()) SWIG_fail;
13729 }
13730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13731 return resultobj;
13732 fail:
13733 return NULL;
13734 }
13735
13736
13737 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13738 PyObject *obj;
13739 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13740 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13741 Py_INCREF(obj);
13742 return Py_BuildValue((char *)"");
13743 }
13744 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13745 PyObject *resultobj;
13746 wxTIFFHandler *result;
13747 char *kwnames[] = {
13748 NULL
13749 };
13750
13751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13752 {
13753 PyThreadState* __tstate = wxPyBeginAllowThreads();
13754 result = (wxTIFFHandler *)new wxTIFFHandler();
13755
13756 wxPyEndAllowThreads(__tstate);
13757 if (PyErr_Occurred()) SWIG_fail;
13758 }
13759 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13760 return resultobj;
13761 fail:
13762 return NULL;
13763 }
13764
13765
13766 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13767 PyObject *obj;
13768 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13769 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13770 Py_INCREF(obj);
13771 return Py_BuildValue((char *)"");
13772 }
13773 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13774 PyObject *resultobj;
13775 wxImage *arg1 = 0 ;
13776 wxImage *arg2 = 0 ;
13777 int arg3 = (int) 236 ;
13778 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13779 bool result;
13780 PyObject * obj0 = 0 ;
13781 PyObject * obj1 = 0 ;
13782 PyObject * obj2 = 0 ;
13783 PyObject * obj3 = 0 ;
13784 char *kwnames[] = {
13785 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13786 };
13787
13788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13789 {
13790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13791 if (SWIG_arg_fail(1)) SWIG_fail;
13792 if (arg1 == NULL) {
13793 SWIG_null_ref("wxImage");
13794 }
13795 if (SWIG_arg_fail(1)) SWIG_fail;
13796 }
13797 {
13798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13799 if (SWIG_arg_fail(2)) SWIG_fail;
13800 if (arg2 == NULL) {
13801 SWIG_null_ref("wxImage");
13802 }
13803 if (SWIG_arg_fail(2)) SWIG_fail;
13804 }
13805 if (obj2) {
13806 {
13807 arg3 = (int)(SWIG_As_int(obj2));
13808 if (SWIG_arg_fail(3)) SWIG_fail;
13809 }
13810 }
13811 if (obj3) {
13812 {
13813 arg4 = (int)(SWIG_As_int(obj3));
13814 if (SWIG_arg_fail(4)) SWIG_fail;
13815 }
13816 }
13817 {
13818 PyThreadState* __tstate = wxPyBeginAllowThreads();
13819 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
13820
13821 wxPyEndAllowThreads(__tstate);
13822 if (PyErr_Occurred()) SWIG_fail;
13823 }
13824 {
13825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13826 }
13827 return resultobj;
13828 fail:
13829 return NULL;
13830 }
13831
13832
13833 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
13834 PyObject *obj;
13835 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13836 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
13837 Py_INCREF(obj);
13838 return Py_BuildValue((char *)"");
13839 }
13840 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13841 PyObject *resultobj;
13842 wxEvtHandler *result;
13843 char *kwnames[] = {
13844 NULL
13845 };
13846
13847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
13848 {
13849 PyThreadState* __tstate = wxPyBeginAllowThreads();
13850 result = (wxEvtHandler *)new wxEvtHandler();
13851
13852 wxPyEndAllowThreads(__tstate);
13853 if (PyErr_Occurred()) SWIG_fail;
13854 }
13855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
13856 return resultobj;
13857 fail:
13858 return NULL;
13859 }
13860
13861
13862 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13863 PyObject *resultobj;
13864 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13865 wxEvtHandler *result;
13866 PyObject * obj0 = 0 ;
13867 char *kwnames[] = {
13868 (char *) "self", NULL
13869 };
13870
13871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
13872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13873 if (SWIG_arg_fail(1)) SWIG_fail;
13874 {
13875 PyThreadState* __tstate = wxPyBeginAllowThreads();
13876 result = (wxEvtHandler *)(arg1)->GetNextHandler();
13877
13878 wxPyEndAllowThreads(__tstate);
13879 if (PyErr_Occurred()) SWIG_fail;
13880 }
13881 {
13882 resultobj = wxPyMake_wxObject(result, 0);
13883 }
13884 return resultobj;
13885 fail:
13886 return NULL;
13887 }
13888
13889
13890 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13891 PyObject *resultobj;
13892 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13893 wxEvtHandler *result;
13894 PyObject * obj0 = 0 ;
13895 char *kwnames[] = {
13896 (char *) "self", NULL
13897 };
13898
13899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
13900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13901 if (SWIG_arg_fail(1)) SWIG_fail;
13902 {
13903 PyThreadState* __tstate = wxPyBeginAllowThreads();
13904 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
13905
13906 wxPyEndAllowThreads(__tstate);
13907 if (PyErr_Occurred()) SWIG_fail;
13908 }
13909 {
13910 resultobj = wxPyMake_wxObject(result, 0);
13911 }
13912 return resultobj;
13913 fail:
13914 return NULL;
13915 }
13916
13917
13918 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13919 PyObject *resultobj;
13920 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13921 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13922 PyObject * obj0 = 0 ;
13923 PyObject * obj1 = 0 ;
13924 char *kwnames[] = {
13925 (char *) "self",(char *) "handler", NULL
13926 };
13927
13928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
13929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13930 if (SWIG_arg_fail(1)) SWIG_fail;
13931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13932 if (SWIG_arg_fail(2)) SWIG_fail;
13933 {
13934 PyThreadState* __tstate = wxPyBeginAllowThreads();
13935 (arg1)->SetNextHandler(arg2);
13936
13937 wxPyEndAllowThreads(__tstate);
13938 if (PyErr_Occurred()) SWIG_fail;
13939 }
13940 Py_INCREF(Py_None); resultobj = Py_None;
13941 return resultobj;
13942 fail:
13943 return NULL;
13944 }
13945
13946
13947 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13948 PyObject *resultobj;
13949 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13950 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
13951 PyObject * obj0 = 0 ;
13952 PyObject * obj1 = 0 ;
13953 char *kwnames[] = {
13954 (char *) "self",(char *) "handler", NULL
13955 };
13956
13957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
13958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13959 if (SWIG_arg_fail(1)) SWIG_fail;
13960 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13961 if (SWIG_arg_fail(2)) SWIG_fail;
13962 {
13963 PyThreadState* __tstate = wxPyBeginAllowThreads();
13964 (arg1)->SetPreviousHandler(arg2);
13965
13966 wxPyEndAllowThreads(__tstate);
13967 if (PyErr_Occurred()) SWIG_fail;
13968 }
13969 Py_INCREF(Py_None); resultobj = Py_None;
13970 return resultobj;
13971 fail:
13972 return NULL;
13973 }
13974
13975
13976 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
13977 PyObject *resultobj;
13978 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
13979 bool result;
13980 PyObject * obj0 = 0 ;
13981 char *kwnames[] = {
13982 (char *) "self", NULL
13983 };
13984
13985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
13986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
13987 if (SWIG_arg_fail(1)) SWIG_fail;
13988 {
13989 PyThreadState* __tstate = wxPyBeginAllowThreads();
13990 result = (bool)(arg1)->GetEvtHandlerEnabled();
13991
13992 wxPyEndAllowThreads(__tstate);
13993 if (PyErr_Occurred()) SWIG_fail;
13994 }
13995 {
13996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13997 }
13998 return resultobj;
13999 fail:
14000 return NULL;
14001 }
14002
14003
14004 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14005 PyObject *resultobj;
14006 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14007 bool arg2 ;
14008 PyObject * obj0 = 0 ;
14009 PyObject * obj1 = 0 ;
14010 char *kwnames[] = {
14011 (char *) "self",(char *) "enabled", NULL
14012 };
14013
14014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14016 if (SWIG_arg_fail(1)) SWIG_fail;
14017 {
14018 arg2 = (bool)(SWIG_As_bool(obj1));
14019 if (SWIG_arg_fail(2)) SWIG_fail;
14020 }
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 (arg1)->SetEvtHandlerEnabled(arg2);
14024
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 Py_INCREF(Py_None); resultobj = Py_None;
14029 return resultobj;
14030 fail:
14031 return NULL;
14032 }
14033
14034
14035 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14036 PyObject *resultobj;
14037 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14038 wxEvent *arg2 = 0 ;
14039 bool result;
14040 PyObject * obj0 = 0 ;
14041 PyObject * obj1 = 0 ;
14042 char *kwnames[] = {
14043 (char *) "self",(char *) "event", NULL
14044 };
14045
14046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14048 if (SWIG_arg_fail(1)) SWIG_fail;
14049 {
14050 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14051 if (SWIG_arg_fail(2)) SWIG_fail;
14052 if (arg2 == NULL) {
14053 SWIG_null_ref("wxEvent");
14054 }
14055 if (SWIG_arg_fail(2)) SWIG_fail;
14056 }
14057 {
14058 PyThreadState* __tstate = wxPyBeginAllowThreads();
14059 result = (bool)(arg1)->ProcessEvent(*arg2);
14060
14061 wxPyEndAllowThreads(__tstate);
14062 if (PyErr_Occurred()) SWIG_fail;
14063 }
14064 {
14065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14066 }
14067 return resultobj;
14068 fail:
14069 return NULL;
14070 }
14071
14072
14073 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14074 PyObject *resultobj;
14075 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14076 wxEvent *arg2 = 0 ;
14077 PyObject * obj0 = 0 ;
14078 PyObject * obj1 = 0 ;
14079 char *kwnames[] = {
14080 (char *) "self",(char *) "event", NULL
14081 };
14082
14083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14085 if (SWIG_arg_fail(1)) SWIG_fail;
14086 {
14087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14088 if (SWIG_arg_fail(2)) SWIG_fail;
14089 if (arg2 == NULL) {
14090 SWIG_null_ref("wxEvent");
14091 }
14092 if (SWIG_arg_fail(2)) SWIG_fail;
14093 }
14094 {
14095 PyThreadState* __tstate = wxPyBeginAllowThreads();
14096 (arg1)->AddPendingEvent(*arg2);
14097
14098 wxPyEndAllowThreads(__tstate);
14099 if (PyErr_Occurred()) SWIG_fail;
14100 }
14101 Py_INCREF(Py_None); resultobj = Py_None;
14102 return resultobj;
14103 fail:
14104 return NULL;
14105 }
14106
14107
14108 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14109 PyObject *resultobj;
14110 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14111 PyObject * obj0 = 0 ;
14112 char *kwnames[] = {
14113 (char *) "self", NULL
14114 };
14115
14116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14118 if (SWIG_arg_fail(1)) SWIG_fail;
14119 {
14120 PyThreadState* __tstate = wxPyBeginAllowThreads();
14121 (arg1)->ProcessPendingEvents();
14122
14123 wxPyEndAllowThreads(__tstate);
14124 if (PyErr_Occurred()) SWIG_fail;
14125 }
14126 Py_INCREF(Py_None); resultobj = Py_None;
14127 return resultobj;
14128 fail:
14129 return NULL;
14130 }
14131
14132
14133 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14134 PyObject *resultobj;
14135 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14136 int arg2 ;
14137 int arg3 ;
14138 int arg4 ;
14139 PyObject *arg5 = (PyObject *) 0 ;
14140 PyObject * obj0 = 0 ;
14141 PyObject * obj1 = 0 ;
14142 PyObject * obj2 = 0 ;
14143 PyObject * obj3 = 0 ;
14144 PyObject * obj4 = 0 ;
14145 char *kwnames[] = {
14146 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14147 };
14148
14149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14151 if (SWIG_arg_fail(1)) SWIG_fail;
14152 {
14153 arg2 = (int)(SWIG_As_int(obj1));
14154 if (SWIG_arg_fail(2)) SWIG_fail;
14155 }
14156 {
14157 arg3 = (int)(SWIG_As_int(obj2));
14158 if (SWIG_arg_fail(3)) SWIG_fail;
14159 }
14160 {
14161 arg4 = (int)(SWIG_As_int(obj3));
14162 if (SWIG_arg_fail(4)) SWIG_fail;
14163 }
14164 arg5 = obj4;
14165 {
14166 PyThreadState* __tstate = wxPyBeginAllowThreads();
14167 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14168
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 Py_INCREF(Py_None); resultobj = Py_None;
14173 return resultobj;
14174 fail:
14175 return NULL;
14176 }
14177
14178
14179 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14180 PyObject *resultobj;
14181 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14182 int arg2 ;
14183 int arg3 = (int) -1 ;
14184 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14185 bool result;
14186 PyObject * obj0 = 0 ;
14187 PyObject * obj1 = 0 ;
14188 PyObject * obj2 = 0 ;
14189 PyObject * obj3 = 0 ;
14190 char *kwnames[] = {
14191 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14192 };
14193
14194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14196 if (SWIG_arg_fail(1)) SWIG_fail;
14197 {
14198 arg2 = (int)(SWIG_As_int(obj1));
14199 if (SWIG_arg_fail(2)) SWIG_fail;
14200 }
14201 if (obj2) {
14202 {
14203 arg3 = (int)(SWIG_As_int(obj2));
14204 if (SWIG_arg_fail(3)) SWIG_fail;
14205 }
14206 }
14207 if (obj3) {
14208 {
14209 arg4 = (wxEventType)(SWIG_As_int(obj3));
14210 if (SWIG_arg_fail(4)) SWIG_fail;
14211 }
14212 }
14213 {
14214 PyThreadState* __tstate = wxPyBeginAllowThreads();
14215 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14216
14217 wxPyEndAllowThreads(__tstate);
14218 if (PyErr_Occurred()) SWIG_fail;
14219 }
14220 {
14221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14222 }
14223 return resultobj;
14224 fail:
14225 return NULL;
14226 }
14227
14228
14229 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14230 PyObject *resultobj;
14231 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14232 PyObject *arg2 = (PyObject *) 0 ;
14233 bool arg3 = (bool) true ;
14234 PyObject * obj0 = 0 ;
14235 PyObject * obj1 = 0 ;
14236 PyObject * obj2 = 0 ;
14237 char *kwnames[] = {
14238 (char *) "self",(char *) "_self",(char *) "incref", NULL
14239 };
14240
14241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14243 if (SWIG_arg_fail(1)) SWIG_fail;
14244 arg2 = obj1;
14245 if (obj2) {
14246 {
14247 arg3 = (bool)(SWIG_As_bool(obj2));
14248 if (SWIG_arg_fail(3)) SWIG_fail;
14249 }
14250 }
14251 {
14252 PyThreadState* __tstate = wxPyBeginAllowThreads();
14253 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14254
14255 wxPyEndAllowThreads(__tstate);
14256 if (PyErr_Occurred()) SWIG_fail;
14257 }
14258 Py_INCREF(Py_None); resultobj = Py_None;
14259 return resultobj;
14260 fail:
14261 return NULL;
14262 }
14263
14264
14265 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14266 PyObject *obj;
14267 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14268 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14269 Py_INCREF(obj);
14270 return Py_BuildValue((char *)"");
14271 }
14272 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14273 PyObject *resultobj;
14274 wxEventType result;
14275 char *kwnames[] = {
14276 NULL
14277 };
14278
14279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14280 {
14281 PyThreadState* __tstate = wxPyBeginAllowThreads();
14282 result = (wxEventType)wxNewEventType();
14283
14284 wxPyEndAllowThreads(__tstate);
14285 if (PyErr_Occurred()) SWIG_fail;
14286 }
14287 {
14288 resultobj = SWIG_From_int((int)(result));
14289 }
14290 return resultobj;
14291 fail:
14292 return NULL;
14293 }
14294
14295
14296 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14297 PyObject *resultobj;
14298 wxEvent *arg1 = (wxEvent *) 0 ;
14299 PyObject * obj0 = 0 ;
14300 char *kwnames[] = {
14301 (char *) "self", NULL
14302 };
14303
14304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14306 if (SWIG_arg_fail(1)) SWIG_fail;
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 delete arg1;
14310
14311 wxPyEndAllowThreads(__tstate);
14312 if (PyErr_Occurred()) SWIG_fail;
14313 }
14314 Py_INCREF(Py_None); resultobj = Py_None;
14315 return resultobj;
14316 fail:
14317 return NULL;
14318 }
14319
14320
14321 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14322 PyObject *resultobj;
14323 wxEvent *arg1 = (wxEvent *) 0 ;
14324 wxEventType arg2 ;
14325 PyObject * obj0 = 0 ;
14326 PyObject * obj1 = 0 ;
14327 char *kwnames[] = {
14328 (char *) "self",(char *) "typ", NULL
14329 };
14330
14331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14333 if (SWIG_arg_fail(1)) SWIG_fail;
14334 {
14335 arg2 = (wxEventType)(SWIG_As_int(obj1));
14336 if (SWIG_arg_fail(2)) SWIG_fail;
14337 }
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 (arg1)->SetEventType(arg2);
14341
14342 wxPyEndAllowThreads(__tstate);
14343 if (PyErr_Occurred()) SWIG_fail;
14344 }
14345 Py_INCREF(Py_None); resultobj = Py_None;
14346 return resultobj;
14347 fail:
14348 return NULL;
14349 }
14350
14351
14352 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14353 PyObject *resultobj;
14354 wxEvent *arg1 = (wxEvent *) 0 ;
14355 wxEventType result;
14356 PyObject * obj0 = 0 ;
14357 char *kwnames[] = {
14358 (char *) "self", NULL
14359 };
14360
14361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14363 if (SWIG_arg_fail(1)) SWIG_fail;
14364 {
14365 PyThreadState* __tstate = wxPyBeginAllowThreads();
14366 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14367
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 {
14372 resultobj = SWIG_From_int((int)(result));
14373 }
14374 return resultobj;
14375 fail:
14376 return NULL;
14377 }
14378
14379
14380 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14381 PyObject *resultobj;
14382 wxEvent *arg1 = (wxEvent *) 0 ;
14383 wxObject *result;
14384 PyObject * obj0 = 0 ;
14385 char *kwnames[] = {
14386 (char *) "self", NULL
14387 };
14388
14389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14391 if (SWIG_arg_fail(1)) SWIG_fail;
14392 {
14393 PyThreadState* __tstate = wxPyBeginAllowThreads();
14394 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14395
14396 wxPyEndAllowThreads(__tstate);
14397 if (PyErr_Occurred()) SWIG_fail;
14398 }
14399 {
14400 resultobj = wxPyMake_wxObject(result, 0);
14401 }
14402 return resultobj;
14403 fail:
14404 return NULL;
14405 }
14406
14407
14408 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14409 PyObject *resultobj;
14410 wxEvent *arg1 = (wxEvent *) 0 ;
14411 wxObject *arg2 = (wxObject *) 0 ;
14412 PyObject * obj0 = 0 ;
14413 PyObject * obj1 = 0 ;
14414 char *kwnames[] = {
14415 (char *) "self",(char *) "obj", NULL
14416 };
14417
14418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14420 if (SWIG_arg_fail(1)) SWIG_fail;
14421 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14422 if (SWIG_arg_fail(2)) SWIG_fail;
14423 {
14424 PyThreadState* __tstate = wxPyBeginAllowThreads();
14425 (arg1)->SetEventObject(arg2);
14426
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 Py_INCREF(Py_None); resultobj = Py_None;
14431 return resultobj;
14432 fail:
14433 return NULL;
14434 }
14435
14436
14437 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14438 PyObject *resultobj;
14439 wxEvent *arg1 = (wxEvent *) 0 ;
14440 long result;
14441 PyObject * obj0 = 0 ;
14442 char *kwnames[] = {
14443 (char *) "self", NULL
14444 };
14445
14446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14448 if (SWIG_arg_fail(1)) SWIG_fail;
14449 {
14450 PyThreadState* __tstate = wxPyBeginAllowThreads();
14451 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14452
14453 wxPyEndAllowThreads(__tstate);
14454 if (PyErr_Occurred()) SWIG_fail;
14455 }
14456 {
14457 resultobj = SWIG_From_long((long)(result));
14458 }
14459 return resultobj;
14460 fail:
14461 return NULL;
14462 }
14463
14464
14465 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14466 PyObject *resultobj;
14467 wxEvent *arg1 = (wxEvent *) 0 ;
14468 long arg2 = (long) 0 ;
14469 PyObject * obj0 = 0 ;
14470 PyObject * obj1 = 0 ;
14471 char *kwnames[] = {
14472 (char *) "self",(char *) "ts", NULL
14473 };
14474
14475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14477 if (SWIG_arg_fail(1)) SWIG_fail;
14478 if (obj1) {
14479 {
14480 arg2 = (long)(SWIG_As_long(obj1));
14481 if (SWIG_arg_fail(2)) SWIG_fail;
14482 }
14483 }
14484 {
14485 PyThreadState* __tstate = wxPyBeginAllowThreads();
14486 (arg1)->SetTimestamp(arg2);
14487
14488 wxPyEndAllowThreads(__tstate);
14489 if (PyErr_Occurred()) SWIG_fail;
14490 }
14491 Py_INCREF(Py_None); resultobj = Py_None;
14492 return resultobj;
14493 fail:
14494 return NULL;
14495 }
14496
14497
14498 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14499 PyObject *resultobj;
14500 wxEvent *arg1 = (wxEvent *) 0 ;
14501 int result;
14502 PyObject * obj0 = 0 ;
14503 char *kwnames[] = {
14504 (char *) "self", NULL
14505 };
14506
14507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14509 if (SWIG_arg_fail(1)) SWIG_fail;
14510 {
14511 PyThreadState* __tstate = wxPyBeginAllowThreads();
14512 result = (int)((wxEvent const *)arg1)->GetId();
14513
14514 wxPyEndAllowThreads(__tstate);
14515 if (PyErr_Occurred()) SWIG_fail;
14516 }
14517 {
14518 resultobj = SWIG_From_int((int)(result));
14519 }
14520 return resultobj;
14521 fail:
14522 return NULL;
14523 }
14524
14525
14526 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14527 PyObject *resultobj;
14528 wxEvent *arg1 = (wxEvent *) 0 ;
14529 int arg2 ;
14530 PyObject * obj0 = 0 ;
14531 PyObject * obj1 = 0 ;
14532 char *kwnames[] = {
14533 (char *) "self",(char *) "Id", NULL
14534 };
14535
14536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14538 if (SWIG_arg_fail(1)) SWIG_fail;
14539 {
14540 arg2 = (int)(SWIG_As_int(obj1));
14541 if (SWIG_arg_fail(2)) SWIG_fail;
14542 }
14543 {
14544 PyThreadState* __tstate = wxPyBeginAllowThreads();
14545 (arg1)->SetId(arg2);
14546
14547 wxPyEndAllowThreads(__tstate);
14548 if (PyErr_Occurred()) SWIG_fail;
14549 }
14550 Py_INCREF(Py_None); resultobj = Py_None;
14551 return resultobj;
14552 fail:
14553 return NULL;
14554 }
14555
14556
14557 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14558 PyObject *resultobj;
14559 wxEvent *arg1 = (wxEvent *) 0 ;
14560 bool result;
14561 PyObject * obj0 = 0 ;
14562 char *kwnames[] = {
14563 (char *) "self", NULL
14564 };
14565
14566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14568 if (SWIG_arg_fail(1)) SWIG_fail;
14569 {
14570 PyThreadState* __tstate = wxPyBeginAllowThreads();
14571 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14572
14573 wxPyEndAllowThreads(__tstate);
14574 if (PyErr_Occurred()) SWIG_fail;
14575 }
14576 {
14577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14578 }
14579 return resultobj;
14580 fail:
14581 return NULL;
14582 }
14583
14584
14585 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14586 PyObject *resultobj;
14587 wxEvent *arg1 = (wxEvent *) 0 ;
14588 bool arg2 = (bool) true ;
14589 PyObject * obj0 = 0 ;
14590 PyObject * obj1 = 0 ;
14591 char *kwnames[] = {
14592 (char *) "self",(char *) "skip", NULL
14593 };
14594
14595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14597 if (SWIG_arg_fail(1)) SWIG_fail;
14598 if (obj1) {
14599 {
14600 arg2 = (bool)(SWIG_As_bool(obj1));
14601 if (SWIG_arg_fail(2)) SWIG_fail;
14602 }
14603 }
14604 {
14605 PyThreadState* __tstate = wxPyBeginAllowThreads();
14606 (arg1)->Skip(arg2);
14607
14608 wxPyEndAllowThreads(__tstate);
14609 if (PyErr_Occurred()) SWIG_fail;
14610 }
14611 Py_INCREF(Py_None); resultobj = Py_None;
14612 return resultobj;
14613 fail:
14614 return NULL;
14615 }
14616
14617
14618 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14619 PyObject *resultobj;
14620 wxEvent *arg1 = (wxEvent *) 0 ;
14621 bool result;
14622 PyObject * obj0 = 0 ;
14623 char *kwnames[] = {
14624 (char *) "self", NULL
14625 };
14626
14627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14629 if (SWIG_arg_fail(1)) SWIG_fail;
14630 {
14631 PyThreadState* __tstate = wxPyBeginAllowThreads();
14632 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14633
14634 wxPyEndAllowThreads(__tstate);
14635 if (PyErr_Occurred()) SWIG_fail;
14636 }
14637 {
14638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14639 }
14640 return resultobj;
14641 fail:
14642 return NULL;
14643 }
14644
14645
14646 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14647 PyObject *resultobj;
14648 wxEvent *arg1 = (wxEvent *) 0 ;
14649 bool result;
14650 PyObject * obj0 = 0 ;
14651 char *kwnames[] = {
14652 (char *) "self", NULL
14653 };
14654
14655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14657 if (SWIG_arg_fail(1)) SWIG_fail;
14658 {
14659 PyThreadState* __tstate = wxPyBeginAllowThreads();
14660 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14661
14662 wxPyEndAllowThreads(__tstate);
14663 if (PyErr_Occurred()) SWIG_fail;
14664 }
14665 {
14666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14667 }
14668 return resultobj;
14669 fail:
14670 return NULL;
14671 }
14672
14673
14674 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14675 PyObject *resultobj;
14676 wxEvent *arg1 = (wxEvent *) 0 ;
14677 int result;
14678 PyObject * obj0 = 0 ;
14679 char *kwnames[] = {
14680 (char *) "self", NULL
14681 };
14682
14683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14685 if (SWIG_arg_fail(1)) SWIG_fail;
14686 {
14687 PyThreadState* __tstate = wxPyBeginAllowThreads();
14688 result = (int)(arg1)->StopPropagation();
14689
14690 wxPyEndAllowThreads(__tstate);
14691 if (PyErr_Occurred()) SWIG_fail;
14692 }
14693 {
14694 resultobj = SWIG_From_int((int)(result));
14695 }
14696 return resultobj;
14697 fail:
14698 return NULL;
14699 }
14700
14701
14702 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14703 PyObject *resultobj;
14704 wxEvent *arg1 = (wxEvent *) 0 ;
14705 int arg2 ;
14706 PyObject * obj0 = 0 ;
14707 PyObject * obj1 = 0 ;
14708 char *kwnames[] = {
14709 (char *) "self",(char *) "propagationLevel", NULL
14710 };
14711
14712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14714 if (SWIG_arg_fail(1)) SWIG_fail;
14715 {
14716 arg2 = (int)(SWIG_As_int(obj1));
14717 if (SWIG_arg_fail(2)) SWIG_fail;
14718 }
14719 {
14720 PyThreadState* __tstate = wxPyBeginAllowThreads();
14721 (arg1)->ResumePropagation(arg2);
14722
14723 wxPyEndAllowThreads(__tstate);
14724 if (PyErr_Occurred()) SWIG_fail;
14725 }
14726 Py_INCREF(Py_None); resultobj = Py_None;
14727 return resultobj;
14728 fail:
14729 return NULL;
14730 }
14731
14732
14733 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14734 PyObject *resultobj;
14735 wxEvent *arg1 = (wxEvent *) 0 ;
14736 wxEvent *result;
14737 PyObject * obj0 = 0 ;
14738 char *kwnames[] = {
14739 (char *) "self", NULL
14740 };
14741
14742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14744 if (SWIG_arg_fail(1)) SWIG_fail;
14745 {
14746 PyThreadState* __tstate = wxPyBeginAllowThreads();
14747 result = (wxEvent *)(arg1)->Clone();
14748
14749 wxPyEndAllowThreads(__tstate);
14750 if (PyErr_Occurred()) SWIG_fail;
14751 }
14752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14753 return resultobj;
14754 fail:
14755 return NULL;
14756 }
14757
14758
14759 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14760 PyObject *obj;
14761 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14762 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14763 Py_INCREF(obj);
14764 return Py_BuildValue((char *)"");
14765 }
14766 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14767 PyObject *resultobj;
14768 wxEvent *arg1 = 0 ;
14769 wxPropagationDisabler *result;
14770 PyObject * obj0 = 0 ;
14771 char *kwnames[] = {
14772 (char *) "event", NULL
14773 };
14774
14775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14776 {
14777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14778 if (SWIG_arg_fail(1)) SWIG_fail;
14779 if (arg1 == NULL) {
14780 SWIG_null_ref("wxEvent");
14781 }
14782 if (SWIG_arg_fail(1)) SWIG_fail;
14783 }
14784 {
14785 PyThreadState* __tstate = wxPyBeginAllowThreads();
14786 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14787
14788 wxPyEndAllowThreads(__tstate);
14789 if (PyErr_Occurred()) SWIG_fail;
14790 }
14791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14792 return resultobj;
14793 fail:
14794 return NULL;
14795 }
14796
14797
14798 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14799 PyObject *resultobj;
14800 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14801 PyObject * obj0 = 0 ;
14802 char *kwnames[] = {
14803 (char *) "self", NULL
14804 };
14805
14806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14808 if (SWIG_arg_fail(1)) SWIG_fail;
14809 {
14810 PyThreadState* __tstate = wxPyBeginAllowThreads();
14811 delete arg1;
14812
14813 wxPyEndAllowThreads(__tstate);
14814 if (PyErr_Occurred()) SWIG_fail;
14815 }
14816 Py_INCREF(Py_None); resultobj = Py_None;
14817 return resultobj;
14818 fail:
14819 return NULL;
14820 }
14821
14822
14823 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
14824 PyObject *obj;
14825 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14826 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
14827 Py_INCREF(obj);
14828 return Py_BuildValue((char *)"");
14829 }
14830 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14831 PyObject *resultobj;
14832 wxEvent *arg1 = 0 ;
14833 wxPropagateOnce *result;
14834 PyObject * obj0 = 0 ;
14835 char *kwnames[] = {
14836 (char *) "event", NULL
14837 };
14838
14839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
14840 {
14841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14842 if (SWIG_arg_fail(1)) SWIG_fail;
14843 if (arg1 == NULL) {
14844 SWIG_null_ref("wxEvent");
14845 }
14846 if (SWIG_arg_fail(1)) SWIG_fail;
14847 }
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
14851
14852 wxPyEndAllowThreads(__tstate);
14853 if (PyErr_Occurred()) SWIG_fail;
14854 }
14855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
14856 return resultobj;
14857 fail:
14858 return NULL;
14859 }
14860
14861
14862 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14863 PyObject *resultobj;
14864 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
14865 PyObject * obj0 = 0 ;
14866 char *kwnames[] = {
14867 (char *) "self", NULL
14868 };
14869
14870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
14871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
14872 if (SWIG_arg_fail(1)) SWIG_fail;
14873 {
14874 PyThreadState* __tstate = wxPyBeginAllowThreads();
14875 delete arg1;
14876
14877 wxPyEndAllowThreads(__tstate);
14878 if (PyErr_Occurred()) SWIG_fail;
14879 }
14880 Py_INCREF(Py_None); resultobj = Py_None;
14881 return resultobj;
14882 fail:
14883 return NULL;
14884 }
14885
14886
14887 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
14888 PyObject *obj;
14889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14890 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
14891 Py_INCREF(obj);
14892 return Py_BuildValue((char *)"");
14893 }
14894 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14895 PyObject *resultobj;
14896 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
14897 int arg2 = (int) 0 ;
14898 wxCommandEvent *result;
14899 PyObject * obj0 = 0 ;
14900 PyObject * obj1 = 0 ;
14901 char *kwnames[] = {
14902 (char *) "commandType",(char *) "winid", NULL
14903 };
14904
14905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
14906 if (obj0) {
14907 {
14908 arg1 = (wxEventType)(SWIG_As_int(obj0));
14909 if (SWIG_arg_fail(1)) SWIG_fail;
14910 }
14911 }
14912 if (obj1) {
14913 {
14914 arg2 = (int)(SWIG_As_int(obj1));
14915 if (SWIG_arg_fail(2)) SWIG_fail;
14916 }
14917 }
14918 {
14919 PyThreadState* __tstate = wxPyBeginAllowThreads();
14920 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
14921
14922 wxPyEndAllowThreads(__tstate);
14923 if (PyErr_Occurred()) SWIG_fail;
14924 }
14925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
14926 return resultobj;
14927 fail:
14928 return NULL;
14929 }
14930
14931
14932 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
14933 PyObject *resultobj;
14934 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14935 int result;
14936 PyObject * obj0 = 0 ;
14937 char *kwnames[] = {
14938 (char *) "self", NULL
14939 };
14940
14941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
14942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14943 if (SWIG_arg_fail(1)) SWIG_fail;
14944 {
14945 PyThreadState* __tstate = wxPyBeginAllowThreads();
14946 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
14947
14948 wxPyEndAllowThreads(__tstate);
14949 if (PyErr_Occurred()) SWIG_fail;
14950 }
14951 {
14952 resultobj = SWIG_From_int((int)(result));
14953 }
14954 return resultobj;
14955 fail:
14956 return NULL;
14957 }
14958
14959
14960 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
14961 PyObject *resultobj;
14962 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
14963 wxString *arg2 = 0 ;
14964 bool temp2 = false ;
14965 PyObject * obj0 = 0 ;
14966 PyObject * obj1 = 0 ;
14967 char *kwnames[] = {
14968 (char *) "self",(char *) "s", NULL
14969 };
14970
14971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
14972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
14973 if (SWIG_arg_fail(1)) SWIG_fail;
14974 {
14975 arg2 = wxString_in_helper(obj1);
14976 if (arg2 == NULL) SWIG_fail;
14977 temp2 = true;
14978 }
14979 {
14980 PyThreadState* __tstate = wxPyBeginAllowThreads();
14981 (arg1)->SetString((wxString const &)*arg2);
14982
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 Py_INCREF(Py_None); resultobj = Py_None;
14987 {
14988 if (temp2)
14989 delete arg2;
14990 }
14991 return resultobj;
14992 fail:
14993 {
14994 if (temp2)
14995 delete arg2;
14996 }
14997 return NULL;
14998 }
14999
15000
15001 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15002 PyObject *resultobj;
15003 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15004 wxString result;
15005 PyObject * obj0 = 0 ;
15006 char *kwnames[] = {
15007 (char *) "self", NULL
15008 };
15009
15010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15012 if (SWIG_arg_fail(1)) SWIG_fail;
15013 {
15014 PyThreadState* __tstate = wxPyBeginAllowThreads();
15015 result = ((wxCommandEvent const *)arg1)->GetString();
15016
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 {
15021 #if wxUSE_UNICODE
15022 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15023 #else
15024 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15025 #endif
15026 }
15027 return resultobj;
15028 fail:
15029 return NULL;
15030 }
15031
15032
15033 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15034 PyObject *resultobj;
15035 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15036 bool result;
15037 PyObject * obj0 = 0 ;
15038 char *kwnames[] = {
15039 (char *) "self", NULL
15040 };
15041
15042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15044 if (SWIG_arg_fail(1)) SWIG_fail;
15045 {
15046 PyThreadState* __tstate = wxPyBeginAllowThreads();
15047 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15048
15049 wxPyEndAllowThreads(__tstate);
15050 if (PyErr_Occurred()) SWIG_fail;
15051 }
15052 {
15053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15054 }
15055 return resultobj;
15056 fail:
15057 return NULL;
15058 }
15059
15060
15061 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15062 PyObject *resultobj;
15063 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15064 bool result;
15065 PyObject * obj0 = 0 ;
15066 char *kwnames[] = {
15067 (char *) "self", NULL
15068 };
15069
15070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15072 if (SWIG_arg_fail(1)) SWIG_fail;
15073 {
15074 PyThreadState* __tstate = wxPyBeginAllowThreads();
15075 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15076
15077 wxPyEndAllowThreads(__tstate);
15078 if (PyErr_Occurred()) SWIG_fail;
15079 }
15080 {
15081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15082 }
15083 return resultobj;
15084 fail:
15085 return NULL;
15086 }
15087
15088
15089 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15090 PyObject *resultobj;
15091 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15092 long arg2 ;
15093 PyObject * obj0 = 0 ;
15094 PyObject * obj1 = 0 ;
15095 char *kwnames[] = {
15096 (char *) "self",(char *) "extraLong", NULL
15097 };
15098
15099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15101 if (SWIG_arg_fail(1)) SWIG_fail;
15102 {
15103 arg2 = (long)(SWIG_As_long(obj1));
15104 if (SWIG_arg_fail(2)) SWIG_fail;
15105 }
15106 {
15107 PyThreadState* __tstate = wxPyBeginAllowThreads();
15108 (arg1)->SetExtraLong(arg2);
15109
15110 wxPyEndAllowThreads(__tstate);
15111 if (PyErr_Occurred()) SWIG_fail;
15112 }
15113 Py_INCREF(Py_None); resultobj = Py_None;
15114 return resultobj;
15115 fail:
15116 return NULL;
15117 }
15118
15119
15120 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15121 PyObject *resultobj;
15122 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15123 long result;
15124 PyObject * obj0 = 0 ;
15125 char *kwnames[] = {
15126 (char *) "self", NULL
15127 };
15128
15129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15131 if (SWIG_arg_fail(1)) SWIG_fail;
15132 {
15133 PyThreadState* __tstate = wxPyBeginAllowThreads();
15134 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15135
15136 wxPyEndAllowThreads(__tstate);
15137 if (PyErr_Occurred()) SWIG_fail;
15138 }
15139 {
15140 resultobj = SWIG_From_long((long)(result));
15141 }
15142 return resultobj;
15143 fail:
15144 return NULL;
15145 }
15146
15147
15148 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15149 PyObject *resultobj;
15150 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15151 int arg2 ;
15152 PyObject * obj0 = 0 ;
15153 PyObject * obj1 = 0 ;
15154 char *kwnames[] = {
15155 (char *) "self",(char *) "i", NULL
15156 };
15157
15158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15160 if (SWIG_arg_fail(1)) SWIG_fail;
15161 {
15162 arg2 = (int)(SWIG_As_int(obj1));
15163 if (SWIG_arg_fail(2)) SWIG_fail;
15164 }
15165 {
15166 PyThreadState* __tstate = wxPyBeginAllowThreads();
15167 (arg1)->SetInt(arg2);
15168
15169 wxPyEndAllowThreads(__tstate);
15170 if (PyErr_Occurred()) SWIG_fail;
15171 }
15172 Py_INCREF(Py_None); resultobj = Py_None;
15173 return resultobj;
15174 fail:
15175 return NULL;
15176 }
15177
15178
15179 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15180 PyObject *resultobj;
15181 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15182 long result;
15183 PyObject * obj0 = 0 ;
15184 char *kwnames[] = {
15185 (char *) "self", NULL
15186 };
15187
15188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15190 if (SWIG_arg_fail(1)) SWIG_fail;
15191 {
15192 PyThreadState* __tstate = wxPyBeginAllowThreads();
15193 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15194
15195 wxPyEndAllowThreads(__tstate);
15196 if (PyErr_Occurred()) SWIG_fail;
15197 }
15198 {
15199 resultobj = SWIG_From_long((long)(result));
15200 }
15201 return resultobj;
15202 fail:
15203 return NULL;
15204 }
15205
15206
15207 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15208 PyObject *resultobj;
15209 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15210 wxEvent *result;
15211 PyObject * obj0 = 0 ;
15212 char *kwnames[] = {
15213 (char *) "self", NULL
15214 };
15215
15216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15218 if (SWIG_arg_fail(1)) SWIG_fail;
15219 {
15220 PyThreadState* __tstate = wxPyBeginAllowThreads();
15221 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15222
15223 wxPyEndAllowThreads(__tstate);
15224 if (PyErr_Occurred()) SWIG_fail;
15225 }
15226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15227 return resultobj;
15228 fail:
15229 return NULL;
15230 }
15231
15232
15233 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15234 PyObject *obj;
15235 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15236 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15237 Py_INCREF(obj);
15238 return Py_BuildValue((char *)"");
15239 }
15240 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15241 PyObject *resultobj;
15242 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15243 int arg2 = (int) 0 ;
15244 wxNotifyEvent *result;
15245 PyObject * obj0 = 0 ;
15246 PyObject * obj1 = 0 ;
15247 char *kwnames[] = {
15248 (char *) "commandType",(char *) "winid", NULL
15249 };
15250
15251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15252 if (obj0) {
15253 {
15254 arg1 = (wxEventType)(SWIG_As_int(obj0));
15255 if (SWIG_arg_fail(1)) SWIG_fail;
15256 }
15257 }
15258 if (obj1) {
15259 {
15260 arg2 = (int)(SWIG_As_int(obj1));
15261 if (SWIG_arg_fail(2)) SWIG_fail;
15262 }
15263 }
15264 {
15265 PyThreadState* __tstate = wxPyBeginAllowThreads();
15266 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15267
15268 wxPyEndAllowThreads(__tstate);
15269 if (PyErr_Occurred()) SWIG_fail;
15270 }
15271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15272 return resultobj;
15273 fail:
15274 return NULL;
15275 }
15276
15277
15278 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15279 PyObject *resultobj;
15280 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15281 PyObject * obj0 = 0 ;
15282 char *kwnames[] = {
15283 (char *) "self", NULL
15284 };
15285
15286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15288 if (SWIG_arg_fail(1)) SWIG_fail;
15289 {
15290 PyThreadState* __tstate = wxPyBeginAllowThreads();
15291 (arg1)->Veto();
15292
15293 wxPyEndAllowThreads(__tstate);
15294 if (PyErr_Occurred()) SWIG_fail;
15295 }
15296 Py_INCREF(Py_None); resultobj = Py_None;
15297 return resultobj;
15298 fail:
15299 return NULL;
15300 }
15301
15302
15303 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15304 PyObject *resultobj;
15305 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15306 PyObject * obj0 = 0 ;
15307 char *kwnames[] = {
15308 (char *) "self", NULL
15309 };
15310
15311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15313 if (SWIG_arg_fail(1)) SWIG_fail;
15314 {
15315 PyThreadState* __tstate = wxPyBeginAllowThreads();
15316 (arg1)->Allow();
15317
15318 wxPyEndAllowThreads(__tstate);
15319 if (PyErr_Occurred()) SWIG_fail;
15320 }
15321 Py_INCREF(Py_None); resultobj = Py_None;
15322 return resultobj;
15323 fail:
15324 return NULL;
15325 }
15326
15327
15328 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15329 PyObject *resultobj;
15330 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15331 bool result;
15332 PyObject * obj0 = 0 ;
15333 char *kwnames[] = {
15334 (char *) "self", NULL
15335 };
15336
15337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15339 if (SWIG_arg_fail(1)) SWIG_fail;
15340 {
15341 PyThreadState* __tstate = wxPyBeginAllowThreads();
15342 result = (bool)(arg1)->IsAllowed();
15343
15344 wxPyEndAllowThreads(__tstate);
15345 if (PyErr_Occurred()) SWIG_fail;
15346 }
15347 {
15348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15349 }
15350 return resultobj;
15351 fail:
15352 return NULL;
15353 }
15354
15355
15356 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15357 PyObject *obj;
15358 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15359 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15360 Py_INCREF(obj);
15361 return Py_BuildValue((char *)"");
15362 }
15363 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15364 PyObject *resultobj;
15365 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15366 int arg2 = (int) 0 ;
15367 int arg3 = (int) 0 ;
15368 int arg4 = (int) 0 ;
15369 wxScrollEvent *result;
15370 PyObject * obj0 = 0 ;
15371 PyObject * obj1 = 0 ;
15372 PyObject * obj2 = 0 ;
15373 PyObject * obj3 = 0 ;
15374 char *kwnames[] = {
15375 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15376 };
15377
15378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15379 if (obj0) {
15380 {
15381 arg1 = (wxEventType)(SWIG_As_int(obj0));
15382 if (SWIG_arg_fail(1)) SWIG_fail;
15383 }
15384 }
15385 if (obj1) {
15386 {
15387 arg2 = (int)(SWIG_As_int(obj1));
15388 if (SWIG_arg_fail(2)) SWIG_fail;
15389 }
15390 }
15391 if (obj2) {
15392 {
15393 arg3 = (int)(SWIG_As_int(obj2));
15394 if (SWIG_arg_fail(3)) SWIG_fail;
15395 }
15396 }
15397 if (obj3) {
15398 {
15399 arg4 = (int)(SWIG_As_int(obj3));
15400 if (SWIG_arg_fail(4)) SWIG_fail;
15401 }
15402 }
15403 {
15404 PyThreadState* __tstate = wxPyBeginAllowThreads();
15405 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15406
15407 wxPyEndAllowThreads(__tstate);
15408 if (PyErr_Occurred()) SWIG_fail;
15409 }
15410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15418 PyObject *resultobj;
15419 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15420 int result;
15421 PyObject * obj0 = 0 ;
15422 char *kwnames[] = {
15423 (char *) "self", NULL
15424 };
15425
15426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15428 if (SWIG_arg_fail(1)) SWIG_fail;
15429 {
15430 PyThreadState* __tstate = wxPyBeginAllowThreads();
15431 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15432
15433 wxPyEndAllowThreads(__tstate);
15434 if (PyErr_Occurred()) SWIG_fail;
15435 }
15436 {
15437 resultobj = SWIG_From_int((int)(result));
15438 }
15439 return resultobj;
15440 fail:
15441 return NULL;
15442 }
15443
15444
15445 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15446 PyObject *resultobj;
15447 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15448 int result;
15449 PyObject * obj0 = 0 ;
15450 char *kwnames[] = {
15451 (char *) "self", NULL
15452 };
15453
15454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15456 if (SWIG_arg_fail(1)) SWIG_fail;
15457 {
15458 PyThreadState* __tstate = wxPyBeginAllowThreads();
15459 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15460
15461 wxPyEndAllowThreads(__tstate);
15462 if (PyErr_Occurred()) SWIG_fail;
15463 }
15464 {
15465 resultobj = SWIG_From_int((int)(result));
15466 }
15467 return resultobj;
15468 fail:
15469 return NULL;
15470 }
15471
15472
15473 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15474 PyObject *resultobj;
15475 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15476 int arg2 ;
15477 PyObject * obj0 = 0 ;
15478 PyObject * obj1 = 0 ;
15479 char *kwnames[] = {
15480 (char *) "self",(char *) "orient", NULL
15481 };
15482
15483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15485 if (SWIG_arg_fail(1)) SWIG_fail;
15486 {
15487 arg2 = (int)(SWIG_As_int(obj1));
15488 if (SWIG_arg_fail(2)) SWIG_fail;
15489 }
15490 {
15491 PyThreadState* __tstate = wxPyBeginAllowThreads();
15492 (arg1)->SetOrientation(arg2);
15493
15494 wxPyEndAllowThreads(__tstate);
15495 if (PyErr_Occurred()) SWIG_fail;
15496 }
15497 Py_INCREF(Py_None); resultobj = Py_None;
15498 return resultobj;
15499 fail:
15500 return NULL;
15501 }
15502
15503
15504 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15505 PyObject *resultobj;
15506 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15507 int arg2 ;
15508 PyObject * obj0 = 0 ;
15509 PyObject * obj1 = 0 ;
15510 char *kwnames[] = {
15511 (char *) "self",(char *) "pos", NULL
15512 };
15513
15514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15516 if (SWIG_arg_fail(1)) SWIG_fail;
15517 {
15518 arg2 = (int)(SWIG_As_int(obj1));
15519 if (SWIG_arg_fail(2)) SWIG_fail;
15520 }
15521 {
15522 PyThreadState* __tstate = wxPyBeginAllowThreads();
15523 (arg1)->SetPosition(arg2);
15524
15525 wxPyEndAllowThreads(__tstate);
15526 if (PyErr_Occurred()) SWIG_fail;
15527 }
15528 Py_INCREF(Py_None); resultobj = Py_None;
15529 return resultobj;
15530 fail:
15531 return NULL;
15532 }
15533
15534
15535 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15536 PyObject *obj;
15537 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15538 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15539 Py_INCREF(obj);
15540 return Py_BuildValue((char *)"");
15541 }
15542 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15543 PyObject *resultobj;
15544 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15545 int arg2 = (int) 0 ;
15546 int arg3 = (int) 0 ;
15547 wxScrollWinEvent *result;
15548 PyObject * obj0 = 0 ;
15549 PyObject * obj1 = 0 ;
15550 PyObject * obj2 = 0 ;
15551 char *kwnames[] = {
15552 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15553 };
15554
15555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15556 if (obj0) {
15557 {
15558 arg1 = (wxEventType)(SWIG_As_int(obj0));
15559 if (SWIG_arg_fail(1)) SWIG_fail;
15560 }
15561 }
15562 if (obj1) {
15563 {
15564 arg2 = (int)(SWIG_As_int(obj1));
15565 if (SWIG_arg_fail(2)) SWIG_fail;
15566 }
15567 }
15568 if (obj2) {
15569 {
15570 arg3 = (int)(SWIG_As_int(obj2));
15571 if (SWIG_arg_fail(3)) SWIG_fail;
15572 }
15573 }
15574 {
15575 PyThreadState* __tstate = wxPyBeginAllowThreads();
15576 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15577
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15589 PyObject *resultobj;
15590 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15591 int result;
15592 PyObject * obj0 = 0 ;
15593 char *kwnames[] = {
15594 (char *) "self", NULL
15595 };
15596
15597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15599 if (SWIG_arg_fail(1)) SWIG_fail;
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15603
15604 wxPyEndAllowThreads(__tstate);
15605 if (PyErr_Occurred()) SWIG_fail;
15606 }
15607 {
15608 resultobj = SWIG_From_int((int)(result));
15609 }
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj;
15618 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15619 int result;
15620 PyObject * obj0 = 0 ;
15621 char *kwnames[] = {
15622 (char *) "self", NULL
15623 };
15624
15625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15627 if (SWIG_arg_fail(1)) SWIG_fail;
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15631
15632 wxPyEndAllowThreads(__tstate);
15633 if (PyErr_Occurred()) SWIG_fail;
15634 }
15635 {
15636 resultobj = SWIG_From_int((int)(result));
15637 }
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15645 PyObject *resultobj;
15646 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15647 int arg2 ;
15648 PyObject * obj0 = 0 ;
15649 PyObject * obj1 = 0 ;
15650 char *kwnames[] = {
15651 (char *) "self",(char *) "orient", NULL
15652 };
15653
15654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15656 if (SWIG_arg_fail(1)) SWIG_fail;
15657 {
15658 arg2 = (int)(SWIG_As_int(obj1));
15659 if (SWIG_arg_fail(2)) SWIG_fail;
15660 }
15661 {
15662 PyThreadState* __tstate = wxPyBeginAllowThreads();
15663 (arg1)->SetOrientation(arg2);
15664
15665 wxPyEndAllowThreads(__tstate);
15666 if (PyErr_Occurred()) SWIG_fail;
15667 }
15668 Py_INCREF(Py_None); resultobj = Py_None;
15669 return resultobj;
15670 fail:
15671 return NULL;
15672 }
15673
15674
15675 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15676 PyObject *resultobj;
15677 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15678 int arg2 ;
15679 PyObject * obj0 = 0 ;
15680 PyObject * obj1 = 0 ;
15681 char *kwnames[] = {
15682 (char *) "self",(char *) "pos", NULL
15683 };
15684
15685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15687 if (SWIG_arg_fail(1)) SWIG_fail;
15688 {
15689 arg2 = (int)(SWIG_As_int(obj1));
15690 if (SWIG_arg_fail(2)) SWIG_fail;
15691 }
15692 {
15693 PyThreadState* __tstate = wxPyBeginAllowThreads();
15694 (arg1)->SetPosition(arg2);
15695
15696 wxPyEndAllowThreads(__tstate);
15697 if (PyErr_Occurred()) SWIG_fail;
15698 }
15699 Py_INCREF(Py_None); resultobj = Py_None;
15700 return resultobj;
15701 fail:
15702 return NULL;
15703 }
15704
15705
15706 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15707 PyObject *obj;
15708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15709 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15710 Py_INCREF(obj);
15711 return Py_BuildValue((char *)"");
15712 }
15713 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15714 PyObject *resultobj;
15715 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15716 wxMouseEvent *result;
15717 PyObject * obj0 = 0 ;
15718 char *kwnames[] = {
15719 (char *) "mouseType", NULL
15720 };
15721
15722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15723 if (obj0) {
15724 {
15725 arg1 = (wxEventType)(SWIG_As_int(obj0));
15726 if (SWIG_arg_fail(1)) SWIG_fail;
15727 }
15728 }
15729 {
15730 PyThreadState* __tstate = wxPyBeginAllowThreads();
15731 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15732
15733 wxPyEndAllowThreads(__tstate);
15734 if (PyErr_Occurred()) SWIG_fail;
15735 }
15736 {
15737 resultobj = wxPyMake_wxObject(result, 1);
15738 }
15739 return resultobj;
15740 fail:
15741 return NULL;
15742 }
15743
15744
15745 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15746 PyObject *resultobj;
15747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15748 bool result;
15749 PyObject * obj0 = 0 ;
15750 char *kwnames[] = {
15751 (char *) "self", NULL
15752 };
15753
15754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15756 if (SWIG_arg_fail(1)) SWIG_fail;
15757 {
15758 PyThreadState* __tstate = wxPyBeginAllowThreads();
15759 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15760
15761 wxPyEndAllowThreads(__tstate);
15762 if (PyErr_Occurred()) SWIG_fail;
15763 }
15764 {
15765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15766 }
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15774 PyObject *resultobj;
15775 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15776 int arg2 = (int) wxMOUSE_BTN_ANY ;
15777 bool result;
15778 PyObject * obj0 = 0 ;
15779 PyObject * obj1 = 0 ;
15780 char *kwnames[] = {
15781 (char *) "self",(char *) "but", NULL
15782 };
15783
15784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15786 if (SWIG_arg_fail(1)) SWIG_fail;
15787 if (obj1) {
15788 {
15789 arg2 = (int)(SWIG_As_int(obj1));
15790 if (SWIG_arg_fail(2)) SWIG_fail;
15791 }
15792 }
15793 {
15794 PyThreadState* __tstate = wxPyBeginAllowThreads();
15795 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15796
15797 wxPyEndAllowThreads(__tstate);
15798 if (PyErr_Occurred()) SWIG_fail;
15799 }
15800 {
15801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15802 }
15803 return resultobj;
15804 fail:
15805 return NULL;
15806 }
15807
15808
15809 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15810 PyObject *resultobj;
15811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15812 int arg2 = (int) wxMOUSE_BTN_ANY ;
15813 bool result;
15814 PyObject * obj0 = 0 ;
15815 PyObject * obj1 = 0 ;
15816 char *kwnames[] = {
15817 (char *) "self",(char *) "but", NULL
15818 };
15819
15820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
15821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15822 if (SWIG_arg_fail(1)) SWIG_fail;
15823 if (obj1) {
15824 {
15825 arg2 = (int)(SWIG_As_int(obj1));
15826 if (SWIG_arg_fail(2)) SWIG_fail;
15827 }
15828 }
15829 {
15830 PyThreadState* __tstate = wxPyBeginAllowThreads();
15831 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
15832
15833 wxPyEndAllowThreads(__tstate);
15834 if (PyErr_Occurred()) SWIG_fail;
15835 }
15836 {
15837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15838 }
15839 return resultobj;
15840 fail:
15841 return NULL;
15842 }
15843
15844
15845 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
15846 PyObject *resultobj;
15847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15848 int arg2 = (int) wxMOUSE_BTN_ANY ;
15849 bool result;
15850 PyObject * obj0 = 0 ;
15851 PyObject * obj1 = 0 ;
15852 char *kwnames[] = {
15853 (char *) "self",(char *) "but", NULL
15854 };
15855
15856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
15857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15858 if (SWIG_arg_fail(1)) SWIG_fail;
15859 if (obj1) {
15860 {
15861 arg2 = (int)(SWIG_As_int(obj1));
15862 if (SWIG_arg_fail(2)) SWIG_fail;
15863 }
15864 }
15865 {
15866 PyThreadState* __tstate = wxPyBeginAllowThreads();
15867 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
15868
15869 wxPyEndAllowThreads(__tstate);
15870 if (PyErr_Occurred()) SWIG_fail;
15871 }
15872 {
15873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15874 }
15875 return resultobj;
15876 fail:
15877 return NULL;
15878 }
15879
15880
15881 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
15882 PyObject *resultobj;
15883 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15884 int arg2 ;
15885 bool result;
15886 PyObject * obj0 = 0 ;
15887 PyObject * obj1 = 0 ;
15888 char *kwnames[] = {
15889 (char *) "self",(char *) "but", NULL
15890 };
15891
15892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
15893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15894 if (SWIG_arg_fail(1)) SWIG_fail;
15895 {
15896 arg2 = (int)(SWIG_As_int(obj1));
15897 if (SWIG_arg_fail(2)) SWIG_fail;
15898 }
15899 {
15900 PyThreadState* __tstate = wxPyBeginAllowThreads();
15901 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
15902
15903 wxPyEndAllowThreads(__tstate);
15904 if (PyErr_Occurred()) SWIG_fail;
15905 }
15906 {
15907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15908 }
15909 return resultobj;
15910 fail:
15911 return NULL;
15912 }
15913
15914
15915 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
15916 PyObject *resultobj;
15917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15918 int arg2 ;
15919 bool result;
15920 PyObject * obj0 = 0 ;
15921 PyObject * obj1 = 0 ;
15922 char *kwnames[] = {
15923 (char *) "self",(char *) "but", NULL
15924 };
15925
15926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
15927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15928 if (SWIG_arg_fail(1)) SWIG_fail;
15929 {
15930 arg2 = (int)(SWIG_As_int(obj1));
15931 if (SWIG_arg_fail(2)) SWIG_fail;
15932 }
15933 {
15934 PyThreadState* __tstate = wxPyBeginAllowThreads();
15935 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
15936
15937 wxPyEndAllowThreads(__tstate);
15938 if (PyErr_Occurred()) SWIG_fail;
15939 }
15940 {
15941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15942 }
15943 return resultobj;
15944 fail:
15945 return NULL;
15946 }
15947
15948
15949 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
15950 PyObject *resultobj;
15951 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15952 int result;
15953 PyObject * obj0 = 0 ;
15954 char *kwnames[] = {
15955 (char *) "self", NULL
15956 };
15957
15958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
15959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15960 if (SWIG_arg_fail(1)) SWIG_fail;
15961 {
15962 PyThreadState* __tstate = wxPyBeginAllowThreads();
15963 result = (int)((wxMouseEvent const *)arg1)->GetButton();
15964
15965 wxPyEndAllowThreads(__tstate);
15966 if (PyErr_Occurred()) SWIG_fail;
15967 }
15968 {
15969 resultobj = SWIG_From_int((int)(result));
15970 }
15971 return resultobj;
15972 fail:
15973 return NULL;
15974 }
15975
15976
15977 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
15978 PyObject *resultobj;
15979 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15980 bool result;
15981 PyObject * obj0 = 0 ;
15982 char *kwnames[] = {
15983 (char *) "self", NULL
15984 };
15985
15986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
15987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15988 if (SWIG_arg_fail(1)) SWIG_fail;
15989 {
15990 PyThreadState* __tstate = wxPyBeginAllowThreads();
15991 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
15992
15993 wxPyEndAllowThreads(__tstate);
15994 if (PyErr_Occurred()) SWIG_fail;
15995 }
15996 {
15997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15998 }
15999 return resultobj;
16000 fail:
16001 return NULL;
16002 }
16003
16004
16005 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16006 PyObject *resultobj;
16007 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16008 bool result;
16009 PyObject * obj0 = 0 ;
16010 char *kwnames[] = {
16011 (char *) "self", NULL
16012 };
16013
16014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16016 if (SWIG_arg_fail(1)) SWIG_fail;
16017 {
16018 PyThreadState* __tstate = wxPyBeginAllowThreads();
16019 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16020
16021 wxPyEndAllowThreads(__tstate);
16022 if (PyErr_Occurred()) SWIG_fail;
16023 }
16024 {
16025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16026 }
16027 return resultobj;
16028 fail:
16029 return NULL;
16030 }
16031
16032
16033 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16034 PyObject *resultobj;
16035 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16036 bool result;
16037 PyObject * obj0 = 0 ;
16038 char *kwnames[] = {
16039 (char *) "self", NULL
16040 };
16041
16042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16044 if (SWIG_arg_fail(1)) SWIG_fail;
16045 {
16046 PyThreadState* __tstate = wxPyBeginAllowThreads();
16047 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16048
16049 wxPyEndAllowThreads(__tstate);
16050 if (PyErr_Occurred()) SWIG_fail;
16051 }
16052 {
16053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16054 }
16055 return resultobj;
16056 fail:
16057 return NULL;
16058 }
16059
16060
16061 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16062 PyObject *resultobj;
16063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16064 bool result;
16065 PyObject * obj0 = 0 ;
16066 char *kwnames[] = {
16067 (char *) "self", NULL
16068 };
16069
16070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16072 if (SWIG_arg_fail(1)) SWIG_fail;
16073 {
16074 PyThreadState* __tstate = wxPyBeginAllowThreads();
16075 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16076
16077 wxPyEndAllowThreads(__tstate);
16078 if (PyErr_Occurred()) SWIG_fail;
16079 }
16080 {
16081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16082 }
16083 return resultobj;
16084 fail:
16085 return NULL;
16086 }
16087
16088
16089 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16090 PyObject *resultobj;
16091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16092 bool result;
16093 PyObject * obj0 = 0 ;
16094 char *kwnames[] = {
16095 (char *) "self", NULL
16096 };
16097
16098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16100 if (SWIG_arg_fail(1)) SWIG_fail;
16101 {
16102 PyThreadState* __tstate = wxPyBeginAllowThreads();
16103 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16104
16105 wxPyEndAllowThreads(__tstate);
16106 if (PyErr_Occurred()) SWIG_fail;
16107 }
16108 {
16109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16110 }
16111 return resultobj;
16112 fail:
16113 return NULL;
16114 }
16115
16116
16117 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16118 PyObject *resultobj;
16119 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16120 bool result;
16121 PyObject * obj0 = 0 ;
16122 char *kwnames[] = {
16123 (char *) "self", NULL
16124 };
16125
16126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16128 if (SWIG_arg_fail(1)) SWIG_fail;
16129 {
16130 PyThreadState* __tstate = wxPyBeginAllowThreads();
16131 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16132
16133 wxPyEndAllowThreads(__tstate);
16134 if (PyErr_Occurred()) SWIG_fail;
16135 }
16136 {
16137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16138 }
16139 return resultobj;
16140 fail:
16141 return NULL;
16142 }
16143
16144
16145 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16146 PyObject *resultobj;
16147 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16148 bool result;
16149 PyObject * obj0 = 0 ;
16150 char *kwnames[] = {
16151 (char *) "self", NULL
16152 };
16153
16154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16156 if (SWIG_arg_fail(1)) SWIG_fail;
16157 {
16158 PyThreadState* __tstate = wxPyBeginAllowThreads();
16159 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16160
16161 wxPyEndAllowThreads(__tstate);
16162 if (PyErr_Occurred()) SWIG_fail;
16163 }
16164 {
16165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16166 }
16167 return resultobj;
16168 fail:
16169 return NULL;
16170 }
16171
16172
16173 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16174 PyObject *resultobj;
16175 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16176 bool result;
16177 PyObject * obj0 = 0 ;
16178 char *kwnames[] = {
16179 (char *) "self", NULL
16180 };
16181
16182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16184 if (SWIG_arg_fail(1)) SWIG_fail;
16185 {
16186 PyThreadState* __tstate = wxPyBeginAllowThreads();
16187 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16188
16189 wxPyEndAllowThreads(__tstate);
16190 if (PyErr_Occurred()) SWIG_fail;
16191 }
16192 {
16193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16194 }
16195 return resultobj;
16196 fail:
16197 return NULL;
16198 }
16199
16200
16201 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16202 PyObject *resultobj;
16203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16204 bool result;
16205 PyObject * obj0 = 0 ;
16206 char *kwnames[] = {
16207 (char *) "self", NULL
16208 };
16209
16210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16212 if (SWIG_arg_fail(1)) SWIG_fail;
16213 {
16214 PyThreadState* __tstate = wxPyBeginAllowThreads();
16215 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16216
16217 wxPyEndAllowThreads(__tstate);
16218 if (PyErr_Occurred()) SWIG_fail;
16219 }
16220 {
16221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16222 }
16223 return resultobj;
16224 fail:
16225 return NULL;
16226 }
16227
16228
16229 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16230 PyObject *resultobj;
16231 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16232 bool result;
16233 PyObject * obj0 = 0 ;
16234 char *kwnames[] = {
16235 (char *) "self", NULL
16236 };
16237
16238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16240 if (SWIG_arg_fail(1)) SWIG_fail;
16241 {
16242 PyThreadState* __tstate = wxPyBeginAllowThreads();
16243 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16244
16245 wxPyEndAllowThreads(__tstate);
16246 if (PyErr_Occurred()) SWIG_fail;
16247 }
16248 {
16249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16250 }
16251 return resultobj;
16252 fail:
16253 return NULL;
16254 }
16255
16256
16257 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16258 PyObject *resultobj;
16259 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16260 bool result;
16261 PyObject * obj0 = 0 ;
16262 char *kwnames[] = {
16263 (char *) "self", NULL
16264 };
16265
16266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16268 if (SWIG_arg_fail(1)) SWIG_fail;
16269 {
16270 PyThreadState* __tstate = wxPyBeginAllowThreads();
16271 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16272
16273 wxPyEndAllowThreads(__tstate);
16274 if (PyErr_Occurred()) SWIG_fail;
16275 }
16276 {
16277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16278 }
16279 return resultobj;
16280 fail:
16281 return NULL;
16282 }
16283
16284
16285 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16286 PyObject *resultobj;
16287 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16288 bool result;
16289 PyObject * obj0 = 0 ;
16290 char *kwnames[] = {
16291 (char *) "self", NULL
16292 };
16293
16294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16296 if (SWIG_arg_fail(1)) SWIG_fail;
16297 {
16298 PyThreadState* __tstate = wxPyBeginAllowThreads();
16299 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16300
16301 wxPyEndAllowThreads(__tstate);
16302 if (PyErr_Occurred()) SWIG_fail;
16303 }
16304 {
16305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16306 }
16307 return resultobj;
16308 fail:
16309 return NULL;
16310 }
16311
16312
16313 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16314 PyObject *resultobj;
16315 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16316 bool result;
16317 PyObject * obj0 = 0 ;
16318 char *kwnames[] = {
16319 (char *) "self", NULL
16320 };
16321
16322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16324 if (SWIG_arg_fail(1)) SWIG_fail;
16325 {
16326 PyThreadState* __tstate = wxPyBeginAllowThreads();
16327 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16328
16329 wxPyEndAllowThreads(__tstate);
16330 if (PyErr_Occurred()) SWIG_fail;
16331 }
16332 {
16333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16334 }
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16342 PyObject *resultobj;
16343 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16344 bool result;
16345 PyObject * obj0 = 0 ;
16346 char *kwnames[] = {
16347 (char *) "self", NULL
16348 };
16349
16350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16352 if (SWIG_arg_fail(1)) SWIG_fail;
16353 {
16354 PyThreadState* __tstate = wxPyBeginAllowThreads();
16355 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16356
16357 wxPyEndAllowThreads(__tstate);
16358 if (PyErr_Occurred()) SWIG_fail;
16359 }
16360 {
16361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16362 }
16363 return resultobj;
16364 fail:
16365 return NULL;
16366 }
16367
16368
16369 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16370 PyObject *resultobj;
16371 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16372 bool result;
16373 PyObject * obj0 = 0 ;
16374 char *kwnames[] = {
16375 (char *) "self", NULL
16376 };
16377
16378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16380 if (SWIG_arg_fail(1)) SWIG_fail;
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 result = (bool)(arg1)->LeftIsDown();
16384
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 {
16389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16390 }
16391 return resultobj;
16392 fail:
16393 return NULL;
16394 }
16395
16396
16397 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj;
16399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16400 bool result;
16401 PyObject * obj0 = 0 ;
16402 char *kwnames[] = {
16403 (char *) "self", NULL
16404 };
16405
16406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16408 if (SWIG_arg_fail(1)) SWIG_fail;
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 result = (bool)(arg1)->MiddleIsDown();
16412
16413 wxPyEndAllowThreads(__tstate);
16414 if (PyErr_Occurred()) SWIG_fail;
16415 }
16416 {
16417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16418 }
16419 return resultobj;
16420 fail:
16421 return NULL;
16422 }
16423
16424
16425 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16426 PyObject *resultobj;
16427 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16428 bool result;
16429 PyObject * obj0 = 0 ;
16430 char *kwnames[] = {
16431 (char *) "self", NULL
16432 };
16433
16434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16436 if (SWIG_arg_fail(1)) SWIG_fail;
16437 {
16438 PyThreadState* __tstate = wxPyBeginAllowThreads();
16439 result = (bool)(arg1)->RightIsDown();
16440
16441 wxPyEndAllowThreads(__tstate);
16442 if (PyErr_Occurred()) SWIG_fail;
16443 }
16444 {
16445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16446 }
16447 return resultobj;
16448 fail:
16449 return NULL;
16450 }
16451
16452
16453 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16454 PyObject *resultobj;
16455 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16456 bool result;
16457 PyObject * obj0 = 0 ;
16458 char *kwnames[] = {
16459 (char *) "self", NULL
16460 };
16461
16462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16464 if (SWIG_arg_fail(1)) SWIG_fail;
16465 {
16466 PyThreadState* __tstate = wxPyBeginAllowThreads();
16467 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16468
16469 wxPyEndAllowThreads(__tstate);
16470 if (PyErr_Occurred()) SWIG_fail;
16471 }
16472 {
16473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16474 }
16475 return resultobj;
16476 fail:
16477 return NULL;
16478 }
16479
16480
16481 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16482 PyObject *resultobj;
16483 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16484 bool result;
16485 PyObject * obj0 = 0 ;
16486 char *kwnames[] = {
16487 (char *) "self", NULL
16488 };
16489
16490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16492 if (SWIG_arg_fail(1)) SWIG_fail;
16493 {
16494 PyThreadState* __tstate = wxPyBeginAllowThreads();
16495 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16496
16497 wxPyEndAllowThreads(__tstate);
16498 if (PyErr_Occurred()) SWIG_fail;
16499 }
16500 {
16501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16502 }
16503 return resultobj;
16504 fail:
16505 return NULL;
16506 }
16507
16508
16509 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16510 PyObject *resultobj;
16511 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16512 bool result;
16513 PyObject * obj0 = 0 ;
16514 char *kwnames[] = {
16515 (char *) "self", NULL
16516 };
16517
16518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16520 if (SWIG_arg_fail(1)) SWIG_fail;
16521 {
16522 PyThreadState* __tstate = wxPyBeginAllowThreads();
16523 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16524
16525 wxPyEndAllowThreads(__tstate);
16526 if (PyErr_Occurred()) SWIG_fail;
16527 }
16528 {
16529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16530 }
16531 return resultobj;
16532 fail:
16533 return NULL;
16534 }
16535
16536
16537 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16538 PyObject *resultobj;
16539 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16540 bool result;
16541 PyObject * obj0 = 0 ;
16542 char *kwnames[] = {
16543 (char *) "self", NULL
16544 };
16545
16546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16548 if (SWIG_arg_fail(1)) SWIG_fail;
16549 {
16550 PyThreadState* __tstate = wxPyBeginAllowThreads();
16551 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16552
16553 wxPyEndAllowThreads(__tstate);
16554 if (PyErr_Occurred()) SWIG_fail;
16555 }
16556 {
16557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16558 }
16559 return resultobj;
16560 fail:
16561 return NULL;
16562 }
16563
16564
16565 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16566 PyObject *resultobj;
16567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16568 wxPoint result;
16569 PyObject * obj0 = 0 ;
16570 char *kwnames[] = {
16571 (char *) "self", NULL
16572 };
16573
16574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16576 if (SWIG_arg_fail(1)) SWIG_fail;
16577 {
16578 PyThreadState* __tstate = wxPyBeginAllowThreads();
16579 result = (arg1)->GetPosition();
16580
16581 wxPyEndAllowThreads(__tstate);
16582 if (PyErr_Occurred()) SWIG_fail;
16583 }
16584 {
16585 wxPoint * resultptr;
16586 resultptr = new wxPoint((wxPoint &)(result));
16587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16588 }
16589 return resultobj;
16590 fail:
16591 return NULL;
16592 }
16593
16594
16595 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16596 PyObject *resultobj;
16597 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16598 long *arg2 = (long *) 0 ;
16599 long *arg3 = (long *) 0 ;
16600 long temp2 ;
16601 int res2 = 0 ;
16602 long temp3 ;
16603 int res3 = 0 ;
16604 PyObject * obj0 = 0 ;
16605 char *kwnames[] = {
16606 (char *) "self", NULL
16607 };
16608
16609 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16610 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16613 if (SWIG_arg_fail(1)) SWIG_fail;
16614 {
16615 PyThreadState* __tstate = wxPyBeginAllowThreads();
16616 (arg1)->GetPosition(arg2,arg3);
16617
16618 wxPyEndAllowThreads(__tstate);
16619 if (PyErr_Occurred()) SWIG_fail;
16620 }
16621 Py_INCREF(Py_None); resultobj = Py_None;
16622 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16623 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16624 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16625 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16626 return resultobj;
16627 fail:
16628 return NULL;
16629 }
16630
16631
16632 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16633 PyObject *resultobj;
16634 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16635 wxDC *arg2 = 0 ;
16636 wxPoint result;
16637 PyObject * obj0 = 0 ;
16638 PyObject * obj1 = 0 ;
16639 char *kwnames[] = {
16640 (char *) "self",(char *) "dc", NULL
16641 };
16642
16643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16645 if (SWIG_arg_fail(1)) SWIG_fail;
16646 {
16647 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16648 if (SWIG_arg_fail(2)) SWIG_fail;
16649 if (arg2 == NULL) {
16650 SWIG_null_ref("wxDC");
16651 }
16652 if (SWIG_arg_fail(2)) SWIG_fail;
16653 }
16654 {
16655 PyThreadState* __tstate = wxPyBeginAllowThreads();
16656 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16657
16658 wxPyEndAllowThreads(__tstate);
16659 if (PyErr_Occurred()) SWIG_fail;
16660 }
16661 {
16662 wxPoint * resultptr;
16663 resultptr = new wxPoint((wxPoint &)(result));
16664 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16665 }
16666 return resultobj;
16667 fail:
16668 return NULL;
16669 }
16670
16671
16672 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16673 PyObject *resultobj;
16674 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16675 int result;
16676 PyObject * obj0 = 0 ;
16677 char *kwnames[] = {
16678 (char *) "self", NULL
16679 };
16680
16681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16683 if (SWIG_arg_fail(1)) SWIG_fail;
16684 {
16685 PyThreadState* __tstate = wxPyBeginAllowThreads();
16686 result = (int)((wxMouseEvent const *)arg1)->GetX();
16687
16688 wxPyEndAllowThreads(__tstate);
16689 if (PyErr_Occurred()) SWIG_fail;
16690 }
16691 {
16692 resultobj = SWIG_From_int((int)(result));
16693 }
16694 return resultobj;
16695 fail:
16696 return NULL;
16697 }
16698
16699
16700 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16701 PyObject *resultobj;
16702 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16703 int result;
16704 PyObject * obj0 = 0 ;
16705 char *kwnames[] = {
16706 (char *) "self", NULL
16707 };
16708
16709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16711 if (SWIG_arg_fail(1)) SWIG_fail;
16712 {
16713 PyThreadState* __tstate = wxPyBeginAllowThreads();
16714 result = (int)((wxMouseEvent const *)arg1)->GetY();
16715
16716 wxPyEndAllowThreads(__tstate);
16717 if (PyErr_Occurred()) SWIG_fail;
16718 }
16719 {
16720 resultobj = SWIG_From_int((int)(result));
16721 }
16722 return resultobj;
16723 fail:
16724 return NULL;
16725 }
16726
16727
16728 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16729 PyObject *resultobj;
16730 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16731 int result;
16732 PyObject * obj0 = 0 ;
16733 char *kwnames[] = {
16734 (char *) "self", NULL
16735 };
16736
16737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16739 if (SWIG_arg_fail(1)) SWIG_fail;
16740 {
16741 PyThreadState* __tstate = wxPyBeginAllowThreads();
16742 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16743
16744 wxPyEndAllowThreads(__tstate);
16745 if (PyErr_Occurred()) SWIG_fail;
16746 }
16747 {
16748 resultobj = SWIG_From_int((int)(result));
16749 }
16750 return resultobj;
16751 fail:
16752 return NULL;
16753 }
16754
16755
16756 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16757 PyObject *resultobj;
16758 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16759 int result;
16760 PyObject * obj0 = 0 ;
16761 char *kwnames[] = {
16762 (char *) "self", NULL
16763 };
16764
16765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16767 if (SWIG_arg_fail(1)) SWIG_fail;
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16771
16772 wxPyEndAllowThreads(__tstate);
16773 if (PyErr_Occurred()) SWIG_fail;
16774 }
16775 {
16776 resultobj = SWIG_From_int((int)(result));
16777 }
16778 return resultobj;
16779 fail:
16780 return NULL;
16781 }
16782
16783
16784 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16785 PyObject *resultobj;
16786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16787 int result;
16788 PyObject * obj0 = 0 ;
16789 char *kwnames[] = {
16790 (char *) "self", NULL
16791 };
16792
16793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16795 if (SWIG_arg_fail(1)) SWIG_fail;
16796 {
16797 PyThreadState* __tstate = wxPyBeginAllowThreads();
16798 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16799
16800 wxPyEndAllowThreads(__tstate);
16801 if (PyErr_Occurred()) SWIG_fail;
16802 }
16803 {
16804 resultobj = SWIG_From_int((int)(result));
16805 }
16806 return resultobj;
16807 fail:
16808 return NULL;
16809 }
16810
16811
16812 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
16813 PyObject *resultobj;
16814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16815 bool result;
16816 PyObject * obj0 = 0 ;
16817 char *kwnames[] = {
16818 (char *) "self", NULL
16819 };
16820
16821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
16822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16823 if (SWIG_arg_fail(1)) SWIG_fail;
16824 {
16825 PyThreadState* __tstate = wxPyBeginAllowThreads();
16826 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
16827
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 {
16832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16833 }
16834 return resultobj;
16835 fail:
16836 return NULL;
16837 }
16838
16839
16840 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
16841 PyObject *resultobj;
16842 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16843 int arg2 ;
16844 PyObject * obj0 = 0 ;
16845 PyObject * obj1 = 0 ;
16846 char *kwnames[] = {
16847 (char *) "self",(char *) "m_x", NULL
16848 };
16849
16850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
16851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16852 if (SWIG_arg_fail(1)) SWIG_fail;
16853 {
16854 arg2 = (int)(SWIG_As_int(obj1));
16855 if (SWIG_arg_fail(2)) SWIG_fail;
16856 }
16857 if (arg1) (arg1)->m_x = arg2;
16858
16859 Py_INCREF(Py_None); resultobj = Py_None;
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
16867 PyObject *resultobj;
16868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16869 int result;
16870 PyObject * obj0 = 0 ;
16871 char *kwnames[] = {
16872 (char *) "self", NULL
16873 };
16874
16875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
16876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16877 if (SWIG_arg_fail(1)) SWIG_fail;
16878 result = (int) ((arg1)->m_x);
16879
16880 {
16881 resultobj = SWIG_From_int((int)(result));
16882 }
16883 return resultobj;
16884 fail:
16885 return NULL;
16886 }
16887
16888
16889 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
16890 PyObject *resultobj;
16891 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16892 int arg2 ;
16893 PyObject * obj0 = 0 ;
16894 PyObject * obj1 = 0 ;
16895 char *kwnames[] = {
16896 (char *) "self",(char *) "m_y", NULL
16897 };
16898
16899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
16900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16901 if (SWIG_arg_fail(1)) SWIG_fail;
16902 {
16903 arg2 = (int)(SWIG_As_int(obj1));
16904 if (SWIG_arg_fail(2)) SWIG_fail;
16905 }
16906 if (arg1) (arg1)->m_y = arg2;
16907
16908 Py_INCREF(Py_None); resultobj = Py_None;
16909 return resultobj;
16910 fail:
16911 return NULL;
16912 }
16913
16914
16915 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
16916 PyObject *resultobj;
16917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16918 int result;
16919 PyObject * obj0 = 0 ;
16920 char *kwnames[] = {
16921 (char *) "self", NULL
16922 };
16923
16924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
16925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16926 if (SWIG_arg_fail(1)) SWIG_fail;
16927 result = (int) ((arg1)->m_y);
16928
16929 {
16930 resultobj = SWIG_From_int((int)(result));
16931 }
16932 return resultobj;
16933 fail:
16934 return NULL;
16935 }
16936
16937
16938 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16939 PyObject *resultobj;
16940 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16941 bool arg2 ;
16942 PyObject * obj0 = 0 ;
16943 PyObject * obj1 = 0 ;
16944 char *kwnames[] = {
16945 (char *) "self",(char *) "m_leftDown", NULL
16946 };
16947
16948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
16949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16950 if (SWIG_arg_fail(1)) SWIG_fail;
16951 {
16952 arg2 = (bool)(SWIG_As_bool(obj1));
16953 if (SWIG_arg_fail(2)) SWIG_fail;
16954 }
16955 if (arg1) (arg1)->m_leftDown = arg2;
16956
16957 Py_INCREF(Py_None); resultobj = Py_None;
16958 return resultobj;
16959 fail:
16960 return NULL;
16961 }
16962
16963
16964 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
16965 PyObject *resultobj;
16966 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16967 bool result;
16968 PyObject * obj0 = 0 ;
16969 char *kwnames[] = {
16970 (char *) "self", NULL
16971 };
16972
16973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
16974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16975 if (SWIG_arg_fail(1)) SWIG_fail;
16976 result = (bool) ((arg1)->m_leftDown);
16977
16978 {
16979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16980 }
16981 return resultobj;
16982 fail:
16983 return NULL;
16984 }
16985
16986
16987 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
16988 PyObject *resultobj;
16989 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16990 bool arg2 ;
16991 PyObject * obj0 = 0 ;
16992 PyObject * obj1 = 0 ;
16993 char *kwnames[] = {
16994 (char *) "self",(char *) "m_middleDown", NULL
16995 };
16996
16997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
16998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16999 if (SWIG_arg_fail(1)) SWIG_fail;
17000 {
17001 arg2 = (bool)(SWIG_As_bool(obj1));
17002 if (SWIG_arg_fail(2)) SWIG_fail;
17003 }
17004 if (arg1) (arg1)->m_middleDown = arg2;
17005
17006 Py_INCREF(Py_None); resultobj = Py_None;
17007 return resultobj;
17008 fail:
17009 return NULL;
17010 }
17011
17012
17013 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17014 PyObject *resultobj;
17015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17016 bool result;
17017 PyObject * obj0 = 0 ;
17018 char *kwnames[] = {
17019 (char *) "self", NULL
17020 };
17021
17022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17024 if (SWIG_arg_fail(1)) SWIG_fail;
17025 result = (bool) ((arg1)->m_middleDown);
17026
17027 {
17028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17029 }
17030 return resultobj;
17031 fail:
17032 return NULL;
17033 }
17034
17035
17036 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17037 PyObject *resultobj;
17038 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17039 bool arg2 ;
17040 PyObject * obj0 = 0 ;
17041 PyObject * obj1 = 0 ;
17042 char *kwnames[] = {
17043 (char *) "self",(char *) "m_rightDown", NULL
17044 };
17045
17046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17048 if (SWIG_arg_fail(1)) SWIG_fail;
17049 {
17050 arg2 = (bool)(SWIG_As_bool(obj1));
17051 if (SWIG_arg_fail(2)) SWIG_fail;
17052 }
17053 if (arg1) (arg1)->m_rightDown = arg2;
17054
17055 Py_INCREF(Py_None); resultobj = Py_None;
17056 return resultobj;
17057 fail:
17058 return NULL;
17059 }
17060
17061
17062 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17063 PyObject *resultobj;
17064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17065 bool result;
17066 PyObject * obj0 = 0 ;
17067 char *kwnames[] = {
17068 (char *) "self", NULL
17069 };
17070
17071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17073 if (SWIG_arg_fail(1)) SWIG_fail;
17074 result = (bool) ((arg1)->m_rightDown);
17075
17076 {
17077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17078 }
17079 return resultobj;
17080 fail:
17081 return NULL;
17082 }
17083
17084
17085 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17086 PyObject *resultobj;
17087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17088 bool arg2 ;
17089 PyObject * obj0 = 0 ;
17090 PyObject * obj1 = 0 ;
17091 char *kwnames[] = {
17092 (char *) "self",(char *) "m_controlDown", NULL
17093 };
17094
17095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17097 if (SWIG_arg_fail(1)) SWIG_fail;
17098 {
17099 arg2 = (bool)(SWIG_As_bool(obj1));
17100 if (SWIG_arg_fail(2)) SWIG_fail;
17101 }
17102 if (arg1) (arg1)->m_controlDown = arg2;
17103
17104 Py_INCREF(Py_None); resultobj = Py_None;
17105 return resultobj;
17106 fail:
17107 return NULL;
17108 }
17109
17110
17111 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17112 PyObject *resultobj;
17113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17114 bool result;
17115 PyObject * obj0 = 0 ;
17116 char *kwnames[] = {
17117 (char *) "self", NULL
17118 };
17119
17120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17122 if (SWIG_arg_fail(1)) SWIG_fail;
17123 result = (bool) ((arg1)->m_controlDown);
17124
17125 {
17126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17127 }
17128 return resultobj;
17129 fail:
17130 return NULL;
17131 }
17132
17133
17134 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17135 PyObject *resultobj;
17136 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17137 bool arg2 ;
17138 PyObject * obj0 = 0 ;
17139 PyObject * obj1 = 0 ;
17140 char *kwnames[] = {
17141 (char *) "self",(char *) "m_shiftDown", NULL
17142 };
17143
17144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17146 if (SWIG_arg_fail(1)) SWIG_fail;
17147 {
17148 arg2 = (bool)(SWIG_As_bool(obj1));
17149 if (SWIG_arg_fail(2)) SWIG_fail;
17150 }
17151 if (arg1) (arg1)->m_shiftDown = arg2;
17152
17153 Py_INCREF(Py_None); resultobj = Py_None;
17154 return resultobj;
17155 fail:
17156 return NULL;
17157 }
17158
17159
17160 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17161 PyObject *resultobj;
17162 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17163 bool result;
17164 PyObject * obj0 = 0 ;
17165 char *kwnames[] = {
17166 (char *) "self", NULL
17167 };
17168
17169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17171 if (SWIG_arg_fail(1)) SWIG_fail;
17172 result = (bool) ((arg1)->m_shiftDown);
17173
17174 {
17175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17176 }
17177 return resultobj;
17178 fail:
17179 return NULL;
17180 }
17181
17182
17183 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17184 PyObject *resultobj;
17185 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17186 bool arg2 ;
17187 PyObject * obj0 = 0 ;
17188 PyObject * obj1 = 0 ;
17189 char *kwnames[] = {
17190 (char *) "self",(char *) "m_altDown", NULL
17191 };
17192
17193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17195 if (SWIG_arg_fail(1)) SWIG_fail;
17196 {
17197 arg2 = (bool)(SWIG_As_bool(obj1));
17198 if (SWIG_arg_fail(2)) SWIG_fail;
17199 }
17200 if (arg1) (arg1)->m_altDown = arg2;
17201
17202 Py_INCREF(Py_None); resultobj = Py_None;
17203 return resultobj;
17204 fail:
17205 return NULL;
17206 }
17207
17208
17209 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17210 PyObject *resultobj;
17211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17212 bool result;
17213 PyObject * obj0 = 0 ;
17214 char *kwnames[] = {
17215 (char *) "self", NULL
17216 };
17217
17218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17220 if (SWIG_arg_fail(1)) SWIG_fail;
17221 result = (bool) ((arg1)->m_altDown);
17222
17223 {
17224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17225 }
17226 return resultobj;
17227 fail:
17228 return NULL;
17229 }
17230
17231
17232 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17233 PyObject *resultobj;
17234 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17235 bool arg2 ;
17236 PyObject * obj0 = 0 ;
17237 PyObject * obj1 = 0 ;
17238 char *kwnames[] = {
17239 (char *) "self",(char *) "m_metaDown", NULL
17240 };
17241
17242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17244 if (SWIG_arg_fail(1)) SWIG_fail;
17245 {
17246 arg2 = (bool)(SWIG_As_bool(obj1));
17247 if (SWIG_arg_fail(2)) SWIG_fail;
17248 }
17249 if (arg1) (arg1)->m_metaDown = arg2;
17250
17251 Py_INCREF(Py_None); resultobj = Py_None;
17252 return resultobj;
17253 fail:
17254 return NULL;
17255 }
17256
17257
17258 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17259 PyObject *resultobj;
17260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17261 bool result;
17262 PyObject * obj0 = 0 ;
17263 char *kwnames[] = {
17264 (char *) "self", NULL
17265 };
17266
17267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17269 if (SWIG_arg_fail(1)) SWIG_fail;
17270 result = (bool) ((arg1)->m_metaDown);
17271
17272 {
17273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17274 }
17275 return resultobj;
17276 fail:
17277 return NULL;
17278 }
17279
17280
17281 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17282 PyObject *resultobj;
17283 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17284 int arg2 ;
17285 PyObject * obj0 = 0 ;
17286 PyObject * obj1 = 0 ;
17287 char *kwnames[] = {
17288 (char *) "self",(char *) "m_wheelRotation", NULL
17289 };
17290
17291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17293 if (SWIG_arg_fail(1)) SWIG_fail;
17294 {
17295 arg2 = (int)(SWIG_As_int(obj1));
17296 if (SWIG_arg_fail(2)) SWIG_fail;
17297 }
17298 if (arg1) (arg1)->m_wheelRotation = arg2;
17299
17300 Py_INCREF(Py_None); resultobj = Py_None;
17301 return resultobj;
17302 fail:
17303 return NULL;
17304 }
17305
17306
17307 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17308 PyObject *resultobj;
17309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17310 int result;
17311 PyObject * obj0 = 0 ;
17312 char *kwnames[] = {
17313 (char *) "self", NULL
17314 };
17315
17316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17318 if (SWIG_arg_fail(1)) SWIG_fail;
17319 result = (int) ((arg1)->m_wheelRotation);
17320
17321 {
17322 resultobj = SWIG_From_int((int)(result));
17323 }
17324 return resultobj;
17325 fail:
17326 return NULL;
17327 }
17328
17329
17330 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17331 PyObject *resultobj;
17332 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17333 int arg2 ;
17334 PyObject * obj0 = 0 ;
17335 PyObject * obj1 = 0 ;
17336 char *kwnames[] = {
17337 (char *) "self",(char *) "m_wheelDelta", NULL
17338 };
17339
17340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
17341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17342 if (SWIG_arg_fail(1)) SWIG_fail;
17343 {
17344 arg2 = (int)(SWIG_As_int(obj1));
17345 if (SWIG_arg_fail(2)) SWIG_fail;
17346 }
17347 if (arg1) (arg1)->m_wheelDelta = arg2;
17348
17349 Py_INCREF(Py_None); resultobj = Py_None;
17350 return resultobj;
17351 fail:
17352 return NULL;
17353 }
17354
17355
17356 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj;
17358 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17359 int result;
17360 PyObject * obj0 = 0 ;
17361 char *kwnames[] = {
17362 (char *) "self", NULL
17363 };
17364
17365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17367 if (SWIG_arg_fail(1)) SWIG_fail;
17368 result = (int) ((arg1)->m_wheelDelta);
17369
17370 {
17371 resultobj = SWIG_From_int((int)(result));
17372 }
17373 return resultobj;
17374 fail:
17375 return NULL;
17376 }
17377
17378
17379 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17380 PyObject *resultobj;
17381 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17382 int arg2 ;
17383 PyObject * obj0 = 0 ;
17384 PyObject * obj1 = 0 ;
17385 char *kwnames[] = {
17386 (char *) "self",(char *) "m_linesPerAction", NULL
17387 };
17388
17389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17391 if (SWIG_arg_fail(1)) SWIG_fail;
17392 {
17393 arg2 = (int)(SWIG_As_int(obj1));
17394 if (SWIG_arg_fail(2)) SWIG_fail;
17395 }
17396 if (arg1) (arg1)->m_linesPerAction = arg2;
17397
17398 Py_INCREF(Py_None); resultobj = Py_None;
17399 return resultobj;
17400 fail:
17401 return NULL;
17402 }
17403
17404
17405 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17406 PyObject *resultobj;
17407 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17408 int result;
17409 PyObject * obj0 = 0 ;
17410 char *kwnames[] = {
17411 (char *) "self", NULL
17412 };
17413
17414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17416 if (SWIG_arg_fail(1)) SWIG_fail;
17417 result = (int) ((arg1)->m_linesPerAction);
17418
17419 {
17420 resultobj = SWIG_From_int((int)(result));
17421 }
17422 return resultobj;
17423 fail:
17424 return NULL;
17425 }
17426
17427
17428 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17429 PyObject *obj;
17430 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17431 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17432 Py_INCREF(obj);
17433 return Py_BuildValue((char *)"");
17434 }
17435 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17436 PyObject *resultobj;
17437 int arg1 = (int) 0 ;
17438 int arg2 = (int) 0 ;
17439 wxSetCursorEvent *result;
17440 PyObject * obj0 = 0 ;
17441 PyObject * obj1 = 0 ;
17442 char *kwnames[] = {
17443 (char *) "x",(char *) "y", NULL
17444 };
17445
17446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17447 if (obj0) {
17448 {
17449 arg1 = (int)(SWIG_As_int(obj0));
17450 if (SWIG_arg_fail(1)) SWIG_fail;
17451 }
17452 }
17453 if (obj1) {
17454 {
17455 arg2 = (int)(SWIG_As_int(obj1));
17456 if (SWIG_arg_fail(2)) SWIG_fail;
17457 }
17458 }
17459 {
17460 PyThreadState* __tstate = wxPyBeginAllowThreads();
17461 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17462
17463 wxPyEndAllowThreads(__tstate);
17464 if (PyErr_Occurred()) SWIG_fail;
17465 }
17466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17467 return resultobj;
17468 fail:
17469 return NULL;
17470 }
17471
17472
17473 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17474 PyObject *resultobj;
17475 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17476 int result;
17477 PyObject * obj0 = 0 ;
17478 char *kwnames[] = {
17479 (char *) "self", NULL
17480 };
17481
17482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17484 if (SWIG_arg_fail(1)) SWIG_fail;
17485 {
17486 PyThreadState* __tstate = wxPyBeginAllowThreads();
17487 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17488
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 {
17493 resultobj = SWIG_From_int((int)(result));
17494 }
17495 return resultobj;
17496 fail:
17497 return NULL;
17498 }
17499
17500
17501 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17502 PyObject *resultobj;
17503 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17504 int result;
17505 PyObject * obj0 = 0 ;
17506 char *kwnames[] = {
17507 (char *) "self", NULL
17508 };
17509
17510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17512 if (SWIG_arg_fail(1)) SWIG_fail;
17513 {
17514 PyThreadState* __tstate = wxPyBeginAllowThreads();
17515 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17516
17517 wxPyEndAllowThreads(__tstate);
17518 if (PyErr_Occurred()) SWIG_fail;
17519 }
17520 {
17521 resultobj = SWIG_From_int((int)(result));
17522 }
17523 return resultobj;
17524 fail:
17525 return NULL;
17526 }
17527
17528
17529 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17530 PyObject *resultobj;
17531 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17532 wxCursor *arg2 = 0 ;
17533 PyObject * obj0 = 0 ;
17534 PyObject * obj1 = 0 ;
17535 char *kwnames[] = {
17536 (char *) "self",(char *) "cursor", NULL
17537 };
17538
17539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17541 if (SWIG_arg_fail(1)) SWIG_fail;
17542 {
17543 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17544 if (SWIG_arg_fail(2)) SWIG_fail;
17545 if (arg2 == NULL) {
17546 SWIG_null_ref("wxCursor");
17547 }
17548 if (SWIG_arg_fail(2)) SWIG_fail;
17549 }
17550 {
17551 PyThreadState* __tstate = wxPyBeginAllowThreads();
17552 (arg1)->SetCursor((wxCursor const &)*arg2);
17553
17554 wxPyEndAllowThreads(__tstate);
17555 if (PyErr_Occurred()) SWIG_fail;
17556 }
17557 Py_INCREF(Py_None); resultobj = Py_None;
17558 return resultobj;
17559 fail:
17560 return NULL;
17561 }
17562
17563
17564 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj;
17566 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17567 wxCursor *result;
17568 PyObject * obj0 = 0 ;
17569 char *kwnames[] = {
17570 (char *) "self", NULL
17571 };
17572
17573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17575 if (SWIG_arg_fail(1)) SWIG_fail;
17576 {
17577 PyThreadState* __tstate = wxPyBeginAllowThreads();
17578 {
17579 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17580 result = (wxCursor *) &_result_ref;
17581 }
17582
17583 wxPyEndAllowThreads(__tstate);
17584 if (PyErr_Occurred()) SWIG_fail;
17585 }
17586 {
17587 wxCursor* resultptr = new wxCursor(*result);
17588 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17589 }
17590 return resultobj;
17591 fail:
17592 return NULL;
17593 }
17594
17595
17596 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17597 PyObject *resultobj;
17598 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17599 bool result;
17600 PyObject * obj0 = 0 ;
17601 char *kwnames[] = {
17602 (char *) "self", NULL
17603 };
17604
17605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17607 if (SWIG_arg_fail(1)) SWIG_fail;
17608 {
17609 PyThreadState* __tstate = wxPyBeginAllowThreads();
17610 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17611
17612 wxPyEndAllowThreads(__tstate);
17613 if (PyErr_Occurred()) SWIG_fail;
17614 }
17615 {
17616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17617 }
17618 return resultobj;
17619 fail:
17620 return NULL;
17621 }
17622
17623
17624 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17625 PyObject *obj;
17626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17627 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17628 Py_INCREF(obj);
17629 return Py_BuildValue((char *)"");
17630 }
17631 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17632 PyObject *resultobj;
17633 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17634 wxKeyEvent *result;
17635 PyObject * obj0 = 0 ;
17636 char *kwnames[] = {
17637 (char *) "keyType", NULL
17638 };
17639
17640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17641 if (obj0) {
17642 {
17643 arg1 = (wxEventType)(SWIG_As_int(obj0));
17644 if (SWIG_arg_fail(1)) SWIG_fail;
17645 }
17646 }
17647 {
17648 PyThreadState* __tstate = wxPyBeginAllowThreads();
17649 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17650
17651 wxPyEndAllowThreads(__tstate);
17652 if (PyErr_Occurred()) SWIG_fail;
17653 }
17654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17655 return resultobj;
17656 fail:
17657 return NULL;
17658 }
17659
17660
17661 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17662 PyObject *resultobj;
17663 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17664 bool result;
17665 PyObject * obj0 = 0 ;
17666 char *kwnames[] = {
17667 (char *) "self", NULL
17668 };
17669
17670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17672 if (SWIG_arg_fail(1)) SWIG_fail;
17673 {
17674 PyThreadState* __tstate = wxPyBeginAllowThreads();
17675 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17676
17677 wxPyEndAllowThreads(__tstate);
17678 if (PyErr_Occurred()) SWIG_fail;
17679 }
17680 {
17681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17682 }
17683 return resultobj;
17684 fail:
17685 return NULL;
17686 }
17687
17688
17689 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17690 PyObject *resultobj;
17691 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17692 bool result;
17693 PyObject * obj0 = 0 ;
17694 char *kwnames[] = {
17695 (char *) "self", NULL
17696 };
17697
17698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17700 if (SWIG_arg_fail(1)) SWIG_fail;
17701 {
17702 PyThreadState* __tstate = wxPyBeginAllowThreads();
17703 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17704
17705 wxPyEndAllowThreads(__tstate);
17706 if (PyErr_Occurred()) SWIG_fail;
17707 }
17708 {
17709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17710 }
17711 return resultobj;
17712 fail:
17713 return NULL;
17714 }
17715
17716
17717 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17718 PyObject *resultobj;
17719 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17720 bool result;
17721 PyObject * obj0 = 0 ;
17722 char *kwnames[] = {
17723 (char *) "self", NULL
17724 };
17725
17726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17728 if (SWIG_arg_fail(1)) SWIG_fail;
17729 {
17730 PyThreadState* __tstate = wxPyBeginAllowThreads();
17731 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17732
17733 wxPyEndAllowThreads(__tstate);
17734 if (PyErr_Occurred()) SWIG_fail;
17735 }
17736 {
17737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17738 }
17739 return resultobj;
17740 fail:
17741 return NULL;
17742 }
17743
17744
17745 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17746 PyObject *resultobj;
17747 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17748 bool result;
17749 PyObject * obj0 = 0 ;
17750 char *kwnames[] = {
17751 (char *) "self", NULL
17752 };
17753
17754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17756 if (SWIG_arg_fail(1)) SWIG_fail;
17757 {
17758 PyThreadState* __tstate = wxPyBeginAllowThreads();
17759 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17760
17761 wxPyEndAllowThreads(__tstate);
17762 if (PyErr_Occurred()) SWIG_fail;
17763 }
17764 {
17765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17766 }
17767 return resultobj;
17768 fail:
17769 return NULL;
17770 }
17771
17772
17773 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17774 PyObject *resultobj;
17775 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17776 bool result;
17777 PyObject * obj0 = 0 ;
17778 char *kwnames[] = {
17779 (char *) "self", NULL
17780 };
17781
17782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17784 if (SWIG_arg_fail(1)) SWIG_fail;
17785 {
17786 PyThreadState* __tstate = wxPyBeginAllowThreads();
17787 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17788
17789 wxPyEndAllowThreads(__tstate);
17790 if (PyErr_Occurred()) SWIG_fail;
17791 }
17792 {
17793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17794 }
17795 return resultobj;
17796 fail:
17797 return NULL;
17798 }
17799
17800
17801 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17802 PyObject *resultobj;
17803 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17804 bool result;
17805 PyObject * obj0 = 0 ;
17806 char *kwnames[] = {
17807 (char *) "self", NULL
17808 };
17809
17810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17812 if (SWIG_arg_fail(1)) SWIG_fail;
17813 {
17814 PyThreadState* __tstate = wxPyBeginAllowThreads();
17815 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
17816
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 {
17821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17822 }
17823 return resultobj;
17824 fail:
17825 return NULL;
17826 }
17827
17828
17829 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17830 PyObject *resultobj;
17831 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17832 int result;
17833 PyObject * obj0 = 0 ;
17834 char *kwnames[] = {
17835 (char *) "self", NULL
17836 };
17837
17838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
17839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17840 if (SWIG_arg_fail(1)) SWIG_fail;
17841 {
17842 PyThreadState* __tstate = wxPyBeginAllowThreads();
17843 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
17844
17845 wxPyEndAllowThreads(__tstate);
17846 if (PyErr_Occurred()) SWIG_fail;
17847 }
17848 {
17849 resultobj = SWIG_From_int((int)(result));
17850 }
17851 return resultobj;
17852 fail:
17853 return NULL;
17854 }
17855
17856
17857 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
17858 PyObject *resultobj;
17859 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17860 int result;
17861 PyObject * obj0 = 0 ;
17862 char *kwnames[] = {
17863 (char *) "self", NULL
17864 };
17865
17866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
17867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17868 if (SWIG_arg_fail(1)) SWIG_fail;
17869 {
17870 PyThreadState* __tstate = wxPyBeginAllowThreads();
17871 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
17872
17873 wxPyEndAllowThreads(__tstate);
17874 if (PyErr_Occurred()) SWIG_fail;
17875 }
17876 {
17877 resultobj = SWIG_From_int((int)(result));
17878 }
17879 return resultobj;
17880 fail:
17881 return NULL;
17882 }
17883
17884
17885 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17886 PyObject *resultobj;
17887 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17888 unsigned int result;
17889 PyObject * obj0 = 0 ;
17890 char *kwnames[] = {
17891 (char *) "self", NULL
17892 };
17893
17894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
17895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17896 if (SWIG_arg_fail(1)) SWIG_fail;
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
17900
17901 wxPyEndAllowThreads(__tstate);
17902 if (PyErr_Occurred()) SWIG_fail;
17903 }
17904 {
17905 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17906 }
17907 return resultobj;
17908 fail:
17909 return NULL;
17910 }
17911
17912
17913 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
17914 PyObject *resultobj;
17915 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17916 unsigned int result;
17917 PyObject * obj0 = 0 ;
17918 char *kwnames[] = {
17919 (char *) "self", NULL
17920 };
17921
17922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
17923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17924 if (SWIG_arg_fail(1)) SWIG_fail;
17925 {
17926 PyThreadState* __tstate = wxPyBeginAllowThreads();
17927 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
17928
17929 wxPyEndAllowThreads(__tstate);
17930 if (PyErr_Occurred()) SWIG_fail;
17931 }
17932 {
17933 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17934 }
17935 return resultobj;
17936 fail:
17937 return NULL;
17938 }
17939
17940
17941 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17942 PyObject *resultobj;
17943 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17944 wxPoint result;
17945 PyObject * obj0 = 0 ;
17946 char *kwnames[] = {
17947 (char *) "self", NULL
17948 };
17949
17950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
17951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17952 if (SWIG_arg_fail(1)) SWIG_fail;
17953 {
17954 PyThreadState* __tstate = wxPyBeginAllowThreads();
17955 result = (arg1)->GetPosition();
17956
17957 wxPyEndAllowThreads(__tstate);
17958 if (PyErr_Occurred()) SWIG_fail;
17959 }
17960 {
17961 wxPoint * resultptr;
17962 resultptr = new wxPoint((wxPoint &)(result));
17963 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17964 }
17965 return resultobj;
17966 fail:
17967 return NULL;
17968 }
17969
17970
17971 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17972 PyObject *resultobj;
17973 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17974 long *arg2 = (long *) 0 ;
17975 long *arg3 = (long *) 0 ;
17976 long temp2 ;
17977 int res2 = 0 ;
17978 long temp3 ;
17979 int res3 = 0 ;
17980 PyObject * obj0 = 0 ;
17981 char *kwnames[] = {
17982 (char *) "self", NULL
17983 };
17984
17985 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17986 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17989 if (SWIG_arg_fail(1)) SWIG_fail;
17990 {
17991 PyThreadState* __tstate = wxPyBeginAllowThreads();
17992 (arg1)->GetPosition(arg2,arg3);
17993
17994 wxPyEndAllowThreads(__tstate);
17995 if (PyErr_Occurred()) SWIG_fail;
17996 }
17997 Py_INCREF(Py_None); resultobj = Py_None;
17998 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17999 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18000 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18001 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18002 return resultobj;
18003 fail:
18004 return NULL;
18005 }
18006
18007
18008 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18009 PyObject *resultobj;
18010 wxKeyEvent *arg1 = (wxKeyEvent *) 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:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18019 if (SWIG_arg_fail(1)) SWIG_fail;
18020 {
18021 PyThreadState* __tstate = wxPyBeginAllowThreads();
18022 result = (int)((wxKeyEvent const *)arg1)->GetX();
18023
18024 wxPyEndAllowThreads(__tstate);
18025 if (PyErr_Occurred()) SWIG_fail;
18026 }
18027 {
18028 resultobj = SWIG_From_int((int)(result));
18029 }
18030 return resultobj;
18031 fail:
18032 return NULL;
18033 }
18034
18035
18036 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18037 PyObject *resultobj;
18038 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18039 int result;
18040 PyObject * obj0 = 0 ;
18041 char *kwnames[] = {
18042 (char *) "self", NULL
18043 };
18044
18045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18047 if (SWIG_arg_fail(1)) SWIG_fail;
18048 {
18049 PyThreadState* __tstate = wxPyBeginAllowThreads();
18050 result = (int)((wxKeyEvent const *)arg1)->GetY();
18051
18052 wxPyEndAllowThreads(__tstate);
18053 if (PyErr_Occurred()) SWIG_fail;
18054 }
18055 {
18056 resultobj = SWIG_From_int((int)(result));
18057 }
18058 return resultobj;
18059 fail:
18060 return NULL;
18061 }
18062
18063
18064 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18065 PyObject *resultobj;
18066 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18067 int arg2 ;
18068 PyObject * obj0 = 0 ;
18069 PyObject * obj1 = 0 ;
18070 char *kwnames[] = {
18071 (char *) "self",(char *) "m_x", NULL
18072 };
18073
18074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18076 if (SWIG_arg_fail(1)) SWIG_fail;
18077 {
18078 arg2 = (int)(SWIG_As_int(obj1));
18079 if (SWIG_arg_fail(2)) SWIG_fail;
18080 }
18081 if (arg1) (arg1)->m_x = arg2;
18082
18083 Py_INCREF(Py_None); resultobj = Py_None;
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18091 PyObject *resultobj;
18092 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18093 int result;
18094 PyObject * obj0 = 0 ;
18095 char *kwnames[] = {
18096 (char *) "self", NULL
18097 };
18098
18099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18101 if (SWIG_arg_fail(1)) SWIG_fail;
18102 result = (int) ((arg1)->m_x);
18103
18104 {
18105 resultobj = SWIG_From_int((int)(result));
18106 }
18107 return resultobj;
18108 fail:
18109 return NULL;
18110 }
18111
18112
18113 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18114 PyObject *resultobj;
18115 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18116 int arg2 ;
18117 PyObject * obj0 = 0 ;
18118 PyObject * obj1 = 0 ;
18119 char *kwnames[] = {
18120 (char *) "self",(char *) "m_y", NULL
18121 };
18122
18123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18125 if (SWIG_arg_fail(1)) SWIG_fail;
18126 {
18127 arg2 = (int)(SWIG_As_int(obj1));
18128 if (SWIG_arg_fail(2)) SWIG_fail;
18129 }
18130 if (arg1) (arg1)->m_y = arg2;
18131
18132 Py_INCREF(Py_None); resultobj = Py_None;
18133 return resultobj;
18134 fail:
18135 return NULL;
18136 }
18137
18138
18139 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18140 PyObject *resultobj;
18141 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18142 int result;
18143 PyObject * obj0 = 0 ;
18144 char *kwnames[] = {
18145 (char *) "self", NULL
18146 };
18147
18148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18150 if (SWIG_arg_fail(1)) SWIG_fail;
18151 result = (int) ((arg1)->m_y);
18152
18153 {
18154 resultobj = SWIG_From_int((int)(result));
18155 }
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18163 PyObject *resultobj;
18164 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18165 long arg2 ;
18166 PyObject * obj0 = 0 ;
18167 PyObject * obj1 = 0 ;
18168 char *kwnames[] = {
18169 (char *) "self",(char *) "m_keyCode", NULL
18170 };
18171
18172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18174 if (SWIG_arg_fail(1)) SWIG_fail;
18175 {
18176 arg2 = (long)(SWIG_As_long(obj1));
18177 if (SWIG_arg_fail(2)) SWIG_fail;
18178 }
18179 if (arg1) (arg1)->m_keyCode = arg2;
18180
18181 Py_INCREF(Py_None); resultobj = Py_None;
18182 return resultobj;
18183 fail:
18184 return NULL;
18185 }
18186
18187
18188 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18189 PyObject *resultobj;
18190 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18191 long result;
18192 PyObject * obj0 = 0 ;
18193 char *kwnames[] = {
18194 (char *) "self", NULL
18195 };
18196
18197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18199 if (SWIG_arg_fail(1)) SWIG_fail;
18200 result = (long) ((arg1)->m_keyCode);
18201
18202 {
18203 resultobj = SWIG_From_long((long)(result));
18204 }
18205 return resultobj;
18206 fail:
18207 return NULL;
18208 }
18209
18210
18211 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18212 PyObject *resultobj;
18213 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18214 bool arg2 ;
18215 PyObject * obj0 = 0 ;
18216 PyObject * obj1 = 0 ;
18217 char *kwnames[] = {
18218 (char *) "self",(char *) "m_controlDown", NULL
18219 };
18220
18221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18223 if (SWIG_arg_fail(1)) SWIG_fail;
18224 {
18225 arg2 = (bool)(SWIG_As_bool(obj1));
18226 if (SWIG_arg_fail(2)) SWIG_fail;
18227 }
18228 if (arg1) (arg1)->m_controlDown = arg2;
18229
18230 Py_INCREF(Py_None); resultobj = Py_None;
18231 return resultobj;
18232 fail:
18233 return NULL;
18234 }
18235
18236
18237 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18238 PyObject *resultobj;
18239 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18240 bool result;
18241 PyObject * obj0 = 0 ;
18242 char *kwnames[] = {
18243 (char *) "self", NULL
18244 };
18245
18246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18248 if (SWIG_arg_fail(1)) SWIG_fail;
18249 result = (bool) ((arg1)->m_controlDown);
18250
18251 {
18252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18253 }
18254 return resultobj;
18255 fail:
18256 return NULL;
18257 }
18258
18259
18260 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18261 PyObject *resultobj;
18262 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18263 bool arg2 ;
18264 PyObject * obj0 = 0 ;
18265 PyObject * obj1 = 0 ;
18266 char *kwnames[] = {
18267 (char *) "self",(char *) "m_shiftDown", NULL
18268 };
18269
18270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18272 if (SWIG_arg_fail(1)) SWIG_fail;
18273 {
18274 arg2 = (bool)(SWIG_As_bool(obj1));
18275 if (SWIG_arg_fail(2)) SWIG_fail;
18276 }
18277 if (arg1) (arg1)->m_shiftDown = arg2;
18278
18279 Py_INCREF(Py_None); resultobj = Py_None;
18280 return resultobj;
18281 fail:
18282 return NULL;
18283 }
18284
18285
18286 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18287 PyObject *resultobj;
18288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18289 bool result;
18290 PyObject * obj0 = 0 ;
18291 char *kwnames[] = {
18292 (char *) "self", NULL
18293 };
18294
18295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18297 if (SWIG_arg_fail(1)) SWIG_fail;
18298 result = (bool) ((arg1)->m_shiftDown);
18299
18300 {
18301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18302 }
18303 return resultobj;
18304 fail:
18305 return NULL;
18306 }
18307
18308
18309 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18310 PyObject *resultobj;
18311 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18312 bool arg2 ;
18313 PyObject * obj0 = 0 ;
18314 PyObject * obj1 = 0 ;
18315 char *kwnames[] = {
18316 (char *) "self",(char *) "m_altDown", NULL
18317 };
18318
18319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18321 if (SWIG_arg_fail(1)) SWIG_fail;
18322 {
18323 arg2 = (bool)(SWIG_As_bool(obj1));
18324 if (SWIG_arg_fail(2)) SWIG_fail;
18325 }
18326 if (arg1) (arg1)->m_altDown = arg2;
18327
18328 Py_INCREF(Py_None); resultobj = Py_None;
18329 return resultobj;
18330 fail:
18331 return NULL;
18332 }
18333
18334
18335 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18336 PyObject *resultobj;
18337 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18338 bool result;
18339 PyObject * obj0 = 0 ;
18340 char *kwnames[] = {
18341 (char *) "self", NULL
18342 };
18343
18344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18346 if (SWIG_arg_fail(1)) SWIG_fail;
18347 result = (bool) ((arg1)->m_altDown);
18348
18349 {
18350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18351 }
18352 return resultobj;
18353 fail:
18354 return NULL;
18355 }
18356
18357
18358 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18359 PyObject *resultobj;
18360 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18361 bool arg2 ;
18362 PyObject * obj0 = 0 ;
18363 PyObject * obj1 = 0 ;
18364 char *kwnames[] = {
18365 (char *) "self",(char *) "m_metaDown", NULL
18366 };
18367
18368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18370 if (SWIG_arg_fail(1)) SWIG_fail;
18371 {
18372 arg2 = (bool)(SWIG_As_bool(obj1));
18373 if (SWIG_arg_fail(2)) SWIG_fail;
18374 }
18375 if (arg1) (arg1)->m_metaDown = arg2;
18376
18377 Py_INCREF(Py_None); resultobj = Py_None;
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18385 PyObject *resultobj;
18386 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18387 bool result;
18388 PyObject * obj0 = 0 ;
18389 char *kwnames[] = {
18390 (char *) "self", NULL
18391 };
18392
18393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18395 if (SWIG_arg_fail(1)) SWIG_fail;
18396 result = (bool) ((arg1)->m_metaDown);
18397
18398 {
18399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18400 }
18401 return resultobj;
18402 fail:
18403 return NULL;
18404 }
18405
18406
18407 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18408 PyObject *resultobj;
18409 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18410 bool arg2 ;
18411 PyObject * obj0 = 0 ;
18412 PyObject * obj1 = 0 ;
18413 char *kwnames[] = {
18414 (char *) "self",(char *) "m_scanCode", NULL
18415 };
18416
18417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18419 if (SWIG_arg_fail(1)) SWIG_fail;
18420 {
18421 arg2 = (bool)(SWIG_As_bool(obj1));
18422 if (SWIG_arg_fail(2)) SWIG_fail;
18423 }
18424 if (arg1) (arg1)->m_scanCode = arg2;
18425
18426 Py_INCREF(Py_None); resultobj = Py_None;
18427 return resultobj;
18428 fail:
18429 return NULL;
18430 }
18431
18432
18433 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18434 PyObject *resultobj;
18435 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18436 bool result;
18437 PyObject * obj0 = 0 ;
18438 char *kwnames[] = {
18439 (char *) "self", NULL
18440 };
18441
18442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18444 if (SWIG_arg_fail(1)) SWIG_fail;
18445 result = (bool) ((arg1)->m_scanCode);
18446
18447 {
18448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18449 }
18450 return resultobj;
18451 fail:
18452 return NULL;
18453 }
18454
18455
18456 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18457 PyObject *resultobj;
18458 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18459 unsigned int arg2 ;
18460 PyObject * obj0 = 0 ;
18461 PyObject * obj1 = 0 ;
18462 char *kwnames[] = {
18463 (char *) "self",(char *) "m_rawCode", NULL
18464 };
18465
18466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18468 if (SWIG_arg_fail(1)) SWIG_fail;
18469 {
18470 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18471 if (SWIG_arg_fail(2)) SWIG_fail;
18472 }
18473 if (arg1) (arg1)->m_rawCode = arg2;
18474
18475 Py_INCREF(Py_None); resultobj = Py_None;
18476 return resultobj;
18477 fail:
18478 return NULL;
18479 }
18480
18481
18482 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18483 PyObject *resultobj;
18484 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18485 unsigned int result;
18486 PyObject * obj0 = 0 ;
18487 char *kwnames[] = {
18488 (char *) "self", NULL
18489 };
18490
18491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18493 if (SWIG_arg_fail(1)) SWIG_fail;
18494 result = (unsigned int) ((arg1)->m_rawCode);
18495
18496 {
18497 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18498 }
18499 return resultobj;
18500 fail:
18501 return NULL;
18502 }
18503
18504
18505 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18506 PyObject *resultobj;
18507 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18508 unsigned int arg2 ;
18509 PyObject * obj0 = 0 ;
18510 PyObject * obj1 = 0 ;
18511 char *kwnames[] = {
18512 (char *) "self",(char *) "m_rawFlags", NULL
18513 };
18514
18515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18517 if (SWIG_arg_fail(1)) SWIG_fail;
18518 {
18519 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18520 if (SWIG_arg_fail(2)) SWIG_fail;
18521 }
18522 if (arg1) (arg1)->m_rawFlags = arg2;
18523
18524 Py_INCREF(Py_None); resultobj = Py_None;
18525 return resultobj;
18526 fail:
18527 return NULL;
18528 }
18529
18530
18531 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18532 PyObject *resultobj;
18533 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18534 unsigned int result;
18535 PyObject * obj0 = 0 ;
18536 char *kwnames[] = {
18537 (char *) "self", NULL
18538 };
18539
18540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18542 if (SWIG_arg_fail(1)) SWIG_fail;
18543 result = (unsigned int) ((arg1)->m_rawFlags);
18544
18545 {
18546 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18547 }
18548 return resultobj;
18549 fail:
18550 return NULL;
18551 }
18552
18553
18554 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18555 PyObject *obj;
18556 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18557 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18558 Py_INCREF(obj);
18559 return Py_BuildValue((char *)"");
18560 }
18561 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18562 PyObject *resultobj;
18563 wxSize const &arg1_defvalue = wxDefaultSize ;
18564 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18565 int arg2 = (int) 0 ;
18566 wxSizeEvent *result;
18567 wxSize temp1 ;
18568 PyObject * obj0 = 0 ;
18569 PyObject * obj1 = 0 ;
18570 char *kwnames[] = {
18571 (char *) "sz",(char *) "winid", NULL
18572 };
18573
18574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18575 if (obj0) {
18576 {
18577 arg1 = &temp1;
18578 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18579 }
18580 }
18581 if (obj1) {
18582 {
18583 arg2 = (int)(SWIG_As_int(obj1));
18584 if (SWIG_arg_fail(2)) SWIG_fail;
18585 }
18586 }
18587 {
18588 PyThreadState* __tstate = wxPyBeginAllowThreads();
18589 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18590
18591 wxPyEndAllowThreads(__tstate);
18592 if (PyErr_Occurred()) SWIG_fail;
18593 }
18594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18595 return resultobj;
18596 fail:
18597 return NULL;
18598 }
18599
18600
18601 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18602 PyObject *resultobj;
18603 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18604 wxSize result;
18605 PyObject * obj0 = 0 ;
18606 char *kwnames[] = {
18607 (char *) "self", NULL
18608 };
18609
18610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18612 if (SWIG_arg_fail(1)) SWIG_fail;
18613 {
18614 PyThreadState* __tstate = wxPyBeginAllowThreads();
18615 result = ((wxSizeEvent const *)arg1)->GetSize();
18616
18617 wxPyEndAllowThreads(__tstate);
18618 if (PyErr_Occurred()) SWIG_fail;
18619 }
18620 {
18621 wxSize * resultptr;
18622 resultptr = new wxSize((wxSize &)(result));
18623 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18624 }
18625 return resultobj;
18626 fail:
18627 return NULL;
18628 }
18629
18630
18631 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18632 PyObject *resultobj;
18633 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18634 wxRect result;
18635 PyObject * obj0 = 0 ;
18636 char *kwnames[] = {
18637 (char *) "self", NULL
18638 };
18639
18640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18642 if (SWIG_arg_fail(1)) SWIG_fail;
18643 {
18644 PyThreadState* __tstate = wxPyBeginAllowThreads();
18645 result = ((wxSizeEvent const *)arg1)->GetRect();
18646
18647 wxPyEndAllowThreads(__tstate);
18648 if (PyErr_Occurred()) SWIG_fail;
18649 }
18650 {
18651 wxRect * resultptr;
18652 resultptr = new wxRect((wxRect &)(result));
18653 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18654 }
18655 return resultobj;
18656 fail:
18657 return NULL;
18658 }
18659
18660
18661 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18662 PyObject *resultobj;
18663 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18664 wxRect arg2 ;
18665 PyObject * obj0 = 0 ;
18666 PyObject * obj1 = 0 ;
18667 char *kwnames[] = {
18668 (char *) "self",(char *) "rect", NULL
18669 };
18670
18671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18673 if (SWIG_arg_fail(1)) SWIG_fail;
18674 {
18675 wxRect * argp;
18676 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18677 if (SWIG_arg_fail(2)) SWIG_fail;
18678 if (argp == NULL) {
18679 SWIG_null_ref("wxRect");
18680 }
18681 if (SWIG_arg_fail(2)) SWIG_fail;
18682 arg2 = *argp;
18683 }
18684 {
18685 PyThreadState* __tstate = wxPyBeginAllowThreads();
18686 (arg1)->SetRect(arg2);
18687
18688 wxPyEndAllowThreads(__tstate);
18689 if (PyErr_Occurred()) SWIG_fail;
18690 }
18691 Py_INCREF(Py_None); resultobj = Py_None;
18692 return resultobj;
18693 fail:
18694 return NULL;
18695 }
18696
18697
18698 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18699 PyObject *resultobj;
18700 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18701 wxSize arg2 ;
18702 PyObject * obj0 = 0 ;
18703 PyObject * obj1 = 0 ;
18704 char *kwnames[] = {
18705 (char *) "self",(char *) "size", NULL
18706 };
18707
18708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18710 if (SWIG_arg_fail(1)) SWIG_fail;
18711 {
18712 wxSize * argp;
18713 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18714 if (SWIG_arg_fail(2)) SWIG_fail;
18715 if (argp == NULL) {
18716 SWIG_null_ref("wxSize");
18717 }
18718 if (SWIG_arg_fail(2)) SWIG_fail;
18719 arg2 = *argp;
18720 }
18721 {
18722 PyThreadState* __tstate = wxPyBeginAllowThreads();
18723 wxSizeEvent_SetSize(arg1,arg2);
18724
18725 wxPyEndAllowThreads(__tstate);
18726 if (PyErr_Occurred()) SWIG_fail;
18727 }
18728 Py_INCREF(Py_None); resultobj = Py_None;
18729 return resultobj;
18730 fail:
18731 return NULL;
18732 }
18733
18734
18735 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18736 PyObject *resultobj;
18737 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18738 wxSize *arg2 = (wxSize *) 0 ;
18739 PyObject * obj0 = 0 ;
18740 PyObject * obj1 = 0 ;
18741 char *kwnames[] = {
18742 (char *) "self",(char *) "m_size", NULL
18743 };
18744
18745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18747 if (SWIG_arg_fail(1)) SWIG_fail;
18748 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18749 if (SWIG_arg_fail(2)) SWIG_fail;
18750 if (arg1) (arg1)->m_size = *arg2;
18751
18752 Py_INCREF(Py_None); resultobj = Py_None;
18753 return resultobj;
18754 fail:
18755 return NULL;
18756 }
18757
18758
18759 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18760 PyObject *resultobj;
18761 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18762 wxSize *result;
18763 PyObject * obj0 = 0 ;
18764 char *kwnames[] = {
18765 (char *) "self", NULL
18766 };
18767
18768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18770 if (SWIG_arg_fail(1)) SWIG_fail;
18771 result = (wxSize *)& ((arg1)->m_size);
18772
18773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18774 return resultobj;
18775 fail:
18776 return NULL;
18777 }
18778
18779
18780 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18781 PyObject *resultobj;
18782 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18783 wxRect *arg2 = (wxRect *) 0 ;
18784 PyObject * obj0 = 0 ;
18785 PyObject * obj1 = 0 ;
18786 char *kwnames[] = {
18787 (char *) "self",(char *) "m_rect", NULL
18788 };
18789
18790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18792 if (SWIG_arg_fail(1)) SWIG_fail;
18793 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18794 if (SWIG_arg_fail(2)) SWIG_fail;
18795 if (arg1) (arg1)->m_rect = *arg2;
18796
18797 Py_INCREF(Py_None); resultobj = Py_None;
18798 return resultobj;
18799 fail:
18800 return NULL;
18801 }
18802
18803
18804 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18805 PyObject *resultobj;
18806 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18807 wxRect *result;
18808 PyObject * obj0 = 0 ;
18809 char *kwnames[] = {
18810 (char *) "self", NULL
18811 };
18812
18813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
18814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18815 if (SWIG_arg_fail(1)) SWIG_fail;
18816 result = (wxRect *)& ((arg1)->m_rect);
18817
18818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
18819 return resultobj;
18820 fail:
18821 return NULL;
18822 }
18823
18824
18825 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
18826 PyObject *obj;
18827 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18828 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
18829 Py_INCREF(obj);
18830 return Py_BuildValue((char *)"");
18831 }
18832 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18833 PyObject *resultobj;
18834 wxPoint const &arg1_defvalue = wxDefaultPosition ;
18835 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
18836 int arg2 = (int) 0 ;
18837 wxMoveEvent *result;
18838 wxPoint temp1 ;
18839 PyObject * obj0 = 0 ;
18840 PyObject * obj1 = 0 ;
18841 char *kwnames[] = {
18842 (char *) "pos",(char *) "winid", NULL
18843 };
18844
18845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
18846 if (obj0) {
18847 {
18848 arg1 = &temp1;
18849 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
18850 }
18851 }
18852 if (obj1) {
18853 {
18854 arg2 = (int)(SWIG_As_int(obj1));
18855 if (SWIG_arg_fail(2)) SWIG_fail;
18856 }
18857 }
18858 {
18859 PyThreadState* __tstate = wxPyBeginAllowThreads();
18860 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
18861
18862 wxPyEndAllowThreads(__tstate);
18863 if (PyErr_Occurred()) SWIG_fail;
18864 }
18865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
18866 return resultobj;
18867 fail:
18868 return NULL;
18869 }
18870
18871
18872 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18873 PyObject *resultobj;
18874 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18875 wxPoint result;
18876 PyObject * obj0 = 0 ;
18877 char *kwnames[] = {
18878 (char *) "self", NULL
18879 };
18880
18881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
18882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18883 if (SWIG_arg_fail(1)) SWIG_fail;
18884 {
18885 PyThreadState* __tstate = wxPyBeginAllowThreads();
18886 result = ((wxMoveEvent const *)arg1)->GetPosition();
18887
18888 wxPyEndAllowThreads(__tstate);
18889 if (PyErr_Occurred()) SWIG_fail;
18890 }
18891 {
18892 wxPoint * resultptr;
18893 resultptr = new wxPoint((wxPoint &)(result));
18894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18895 }
18896 return resultobj;
18897 fail:
18898 return NULL;
18899 }
18900
18901
18902 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18903 PyObject *resultobj;
18904 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18905 wxRect result;
18906 PyObject * obj0 = 0 ;
18907 char *kwnames[] = {
18908 (char *) "self", NULL
18909 };
18910
18911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
18912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18913 if (SWIG_arg_fail(1)) SWIG_fail;
18914 {
18915 PyThreadState* __tstate = wxPyBeginAllowThreads();
18916 result = ((wxMoveEvent const *)arg1)->GetRect();
18917
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 {
18922 wxRect * resultptr;
18923 resultptr = new wxRect((wxRect &)(result));
18924 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18925 }
18926 return resultobj;
18927 fail:
18928 return NULL;
18929 }
18930
18931
18932 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18933 PyObject *resultobj;
18934 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18935 wxRect *arg2 = 0 ;
18936 wxRect temp2 ;
18937 PyObject * obj0 = 0 ;
18938 PyObject * obj1 = 0 ;
18939 char *kwnames[] = {
18940 (char *) "self",(char *) "rect", NULL
18941 };
18942
18943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18945 if (SWIG_arg_fail(1)) SWIG_fail;
18946 {
18947 arg2 = &temp2;
18948 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18949 }
18950 {
18951 PyThreadState* __tstate = wxPyBeginAllowThreads();
18952 (arg1)->SetRect((wxRect const &)*arg2);
18953
18954 wxPyEndAllowThreads(__tstate);
18955 if (PyErr_Occurred()) SWIG_fail;
18956 }
18957 Py_INCREF(Py_None); resultobj = Py_None;
18958 return resultobj;
18959 fail:
18960 return NULL;
18961 }
18962
18963
18964 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18965 PyObject *resultobj;
18966 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
18967 wxPoint *arg2 = 0 ;
18968 wxPoint temp2 ;
18969 PyObject * obj0 = 0 ;
18970 PyObject * obj1 = 0 ;
18971 char *kwnames[] = {
18972 (char *) "self",(char *) "pos", NULL
18973 };
18974
18975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
18976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
18977 if (SWIG_arg_fail(1)) SWIG_fail;
18978 {
18979 arg2 = &temp2;
18980 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
18981 }
18982 {
18983 PyThreadState* __tstate = wxPyBeginAllowThreads();
18984 (arg1)->SetPosition((wxPoint const &)*arg2);
18985
18986 wxPyEndAllowThreads(__tstate);
18987 if (PyErr_Occurred()) SWIG_fail;
18988 }
18989 Py_INCREF(Py_None); resultobj = Py_None;
18990 return resultobj;
18991 fail:
18992 return NULL;
18993 }
18994
18995
18996 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
18997 PyObject *obj;
18998 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18999 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19000 Py_INCREF(obj);
19001 return Py_BuildValue((char *)"");
19002 }
19003 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19004 PyObject *resultobj;
19005 int arg1 = (int) 0 ;
19006 wxPaintEvent *result;
19007 PyObject * obj0 = 0 ;
19008 char *kwnames[] = {
19009 (char *) "Id", NULL
19010 };
19011
19012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19013 if (obj0) {
19014 {
19015 arg1 = (int)(SWIG_As_int(obj0));
19016 if (SWIG_arg_fail(1)) SWIG_fail;
19017 }
19018 }
19019 {
19020 PyThreadState* __tstate = wxPyBeginAllowThreads();
19021 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19022
19023 wxPyEndAllowThreads(__tstate);
19024 if (PyErr_Occurred()) SWIG_fail;
19025 }
19026 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19027 return resultobj;
19028 fail:
19029 return NULL;
19030 }
19031
19032
19033 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19034 PyObject *obj;
19035 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19036 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19037 Py_INCREF(obj);
19038 return Py_BuildValue((char *)"");
19039 }
19040 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19041 PyObject *resultobj;
19042 int arg1 = (int) 0 ;
19043 wxNcPaintEvent *result;
19044 PyObject * obj0 = 0 ;
19045 char *kwnames[] = {
19046 (char *) "winid", NULL
19047 };
19048
19049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19050 if (obj0) {
19051 {
19052 arg1 = (int)(SWIG_As_int(obj0));
19053 if (SWIG_arg_fail(1)) SWIG_fail;
19054 }
19055 }
19056 {
19057 PyThreadState* __tstate = wxPyBeginAllowThreads();
19058 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19059
19060 wxPyEndAllowThreads(__tstate);
19061 if (PyErr_Occurred()) SWIG_fail;
19062 }
19063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19064 return resultobj;
19065 fail:
19066 return NULL;
19067 }
19068
19069
19070 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19071 PyObject *obj;
19072 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19073 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19074 Py_INCREF(obj);
19075 return Py_BuildValue((char *)"");
19076 }
19077 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19078 PyObject *resultobj;
19079 int arg1 = (int) 0 ;
19080 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19081 wxEraseEvent *result;
19082 PyObject * obj0 = 0 ;
19083 PyObject * obj1 = 0 ;
19084 char *kwnames[] = {
19085 (char *) "Id",(char *) "dc", NULL
19086 };
19087
19088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19089 if (obj0) {
19090 {
19091 arg1 = (int)(SWIG_As_int(obj0));
19092 if (SWIG_arg_fail(1)) SWIG_fail;
19093 }
19094 }
19095 if (obj1) {
19096 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19097 if (SWIG_arg_fail(2)) SWIG_fail;
19098 }
19099 {
19100 PyThreadState* __tstate = wxPyBeginAllowThreads();
19101 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19102
19103 wxPyEndAllowThreads(__tstate);
19104 if (PyErr_Occurred()) SWIG_fail;
19105 }
19106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19107 return resultobj;
19108 fail:
19109 return NULL;
19110 }
19111
19112
19113 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19114 PyObject *resultobj;
19115 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19116 wxDC *result;
19117 PyObject * obj0 = 0 ;
19118 char *kwnames[] = {
19119 (char *) "self", NULL
19120 };
19121
19122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19124 if (SWIG_arg_fail(1)) SWIG_fail;
19125 {
19126 PyThreadState* __tstate = wxPyBeginAllowThreads();
19127 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19128
19129 wxPyEndAllowThreads(__tstate);
19130 if (PyErr_Occurred()) SWIG_fail;
19131 }
19132 {
19133 resultobj = wxPyMake_wxObject(result, 0);
19134 }
19135 return resultobj;
19136 fail:
19137 return NULL;
19138 }
19139
19140
19141 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19142 PyObject *obj;
19143 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19144 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19145 Py_INCREF(obj);
19146 return Py_BuildValue((char *)"");
19147 }
19148 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19149 PyObject *resultobj;
19150 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19151 int arg2 = (int) 0 ;
19152 wxFocusEvent *result;
19153 PyObject * obj0 = 0 ;
19154 PyObject * obj1 = 0 ;
19155 char *kwnames[] = {
19156 (char *) "type",(char *) "winid", NULL
19157 };
19158
19159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19160 if (obj0) {
19161 {
19162 arg1 = (wxEventType)(SWIG_As_int(obj0));
19163 if (SWIG_arg_fail(1)) SWIG_fail;
19164 }
19165 }
19166 if (obj1) {
19167 {
19168 arg2 = (int)(SWIG_As_int(obj1));
19169 if (SWIG_arg_fail(2)) SWIG_fail;
19170 }
19171 }
19172 {
19173 PyThreadState* __tstate = wxPyBeginAllowThreads();
19174 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19175
19176 wxPyEndAllowThreads(__tstate);
19177 if (PyErr_Occurred()) SWIG_fail;
19178 }
19179 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19180 return resultobj;
19181 fail:
19182 return NULL;
19183 }
19184
19185
19186 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19187 PyObject *resultobj;
19188 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19189 wxWindow *result;
19190 PyObject * obj0 = 0 ;
19191 char *kwnames[] = {
19192 (char *) "self", NULL
19193 };
19194
19195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19197 if (SWIG_arg_fail(1)) SWIG_fail;
19198 {
19199 PyThreadState* __tstate = wxPyBeginAllowThreads();
19200 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19201
19202 wxPyEndAllowThreads(__tstate);
19203 if (PyErr_Occurred()) SWIG_fail;
19204 }
19205 {
19206 resultobj = wxPyMake_wxObject(result, 0);
19207 }
19208 return resultobj;
19209 fail:
19210 return NULL;
19211 }
19212
19213
19214 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19215 PyObject *resultobj;
19216 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19217 wxWindow *arg2 = (wxWindow *) 0 ;
19218 PyObject * obj0 = 0 ;
19219 PyObject * obj1 = 0 ;
19220 char *kwnames[] = {
19221 (char *) "self",(char *) "win", NULL
19222 };
19223
19224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19226 if (SWIG_arg_fail(1)) SWIG_fail;
19227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19228 if (SWIG_arg_fail(2)) SWIG_fail;
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 (arg1)->SetWindow(arg2);
19232
19233 wxPyEndAllowThreads(__tstate);
19234 if (PyErr_Occurred()) SWIG_fail;
19235 }
19236 Py_INCREF(Py_None); resultobj = Py_None;
19237 return resultobj;
19238 fail:
19239 return NULL;
19240 }
19241
19242
19243 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19244 PyObject *obj;
19245 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19246 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19247 Py_INCREF(obj);
19248 return Py_BuildValue((char *)"");
19249 }
19250 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19251 PyObject *resultobj;
19252 wxWindow *arg1 = (wxWindow *) NULL ;
19253 wxChildFocusEvent *result;
19254 PyObject * obj0 = 0 ;
19255 char *kwnames[] = {
19256 (char *) "win", NULL
19257 };
19258
19259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19260 if (obj0) {
19261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19262 if (SWIG_arg_fail(1)) SWIG_fail;
19263 }
19264 {
19265 PyThreadState* __tstate = wxPyBeginAllowThreads();
19266 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19267
19268 wxPyEndAllowThreads(__tstate);
19269 if (PyErr_Occurred()) SWIG_fail;
19270 }
19271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19279 PyObject *resultobj;
19280 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19281 wxWindow *result;
19282 PyObject * obj0 = 0 ;
19283 char *kwnames[] = {
19284 (char *) "self", NULL
19285 };
19286
19287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19289 if (SWIG_arg_fail(1)) SWIG_fail;
19290 {
19291 PyThreadState* __tstate = wxPyBeginAllowThreads();
19292 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19293
19294 wxPyEndAllowThreads(__tstate);
19295 if (PyErr_Occurred()) SWIG_fail;
19296 }
19297 {
19298 resultobj = wxPyMake_wxObject(result, 0);
19299 }
19300 return resultobj;
19301 fail:
19302 return NULL;
19303 }
19304
19305
19306 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19307 PyObject *obj;
19308 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19309 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19310 Py_INCREF(obj);
19311 return Py_BuildValue((char *)"");
19312 }
19313 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19314 PyObject *resultobj;
19315 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19316 bool arg2 = (bool) true ;
19317 int arg3 = (int) 0 ;
19318 wxActivateEvent *result;
19319 PyObject * obj0 = 0 ;
19320 PyObject * obj1 = 0 ;
19321 PyObject * obj2 = 0 ;
19322 char *kwnames[] = {
19323 (char *) "type",(char *) "active",(char *) "Id", NULL
19324 };
19325
19326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19327 if (obj0) {
19328 {
19329 arg1 = (wxEventType)(SWIG_As_int(obj0));
19330 if (SWIG_arg_fail(1)) SWIG_fail;
19331 }
19332 }
19333 if (obj1) {
19334 {
19335 arg2 = (bool)(SWIG_As_bool(obj1));
19336 if (SWIG_arg_fail(2)) SWIG_fail;
19337 }
19338 }
19339 if (obj2) {
19340 {
19341 arg3 = (int)(SWIG_As_int(obj2));
19342 if (SWIG_arg_fail(3)) SWIG_fail;
19343 }
19344 }
19345 {
19346 PyThreadState* __tstate = wxPyBeginAllowThreads();
19347 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19348
19349 wxPyEndAllowThreads(__tstate);
19350 if (PyErr_Occurred()) SWIG_fail;
19351 }
19352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19353 return resultobj;
19354 fail:
19355 return NULL;
19356 }
19357
19358
19359 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19360 PyObject *resultobj;
19361 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19362 bool result;
19363 PyObject * obj0 = 0 ;
19364 char *kwnames[] = {
19365 (char *) "self", NULL
19366 };
19367
19368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19370 if (SWIG_arg_fail(1)) SWIG_fail;
19371 {
19372 PyThreadState* __tstate = wxPyBeginAllowThreads();
19373 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19374
19375 wxPyEndAllowThreads(__tstate);
19376 if (PyErr_Occurred()) SWIG_fail;
19377 }
19378 {
19379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19380 }
19381 return resultobj;
19382 fail:
19383 return NULL;
19384 }
19385
19386
19387 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19388 PyObject *obj;
19389 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19390 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19391 Py_INCREF(obj);
19392 return Py_BuildValue((char *)"");
19393 }
19394 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19395 PyObject *resultobj;
19396 int arg1 = (int) 0 ;
19397 wxInitDialogEvent *result;
19398 PyObject * obj0 = 0 ;
19399 char *kwnames[] = {
19400 (char *) "Id", NULL
19401 };
19402
19403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19404 if (obj0) {
19405 {
19406 arg1 = (int)(SWIG_As_int(obj0));
19407 if (SWIG_arg_fail(1)) SWIG_fail;
19408 }
19409 }
19410 {
19411 PyThreadState* __tstate = wxPyBeginAllowThreads();
19412 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19413
19414 wxPyEndAllowThreads(__tstate);
19415 if (PyErr_Occurred()) SWIG_fail;
19416 }
19417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19418 return resultobj;
19419 fail:
19420 return NULL;
19421 }
19422
19423
19424 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19425 PyObject *obj;
19426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19427 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19428 Py_INCREF(obj);
19429 return Py_BuildValue((char *)"");
19430 }
19431 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19432 PyObject *resultobj;
19433 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19434 int arg2 = (int) 0 ;
19435 wxMenu *arg3 = (wxMenu *) NULL ;
19436 wxMenuEvent *result;
19437 PyObject * obj0 = 0 ;
19438 PyObject * obj1 = 0 ;
19439 PyObject * obj2 = 0 ;
19440 char *kwnames[] = {
19441 (char *) "type",(char *) "winid",(char *) "menu", NULL
19442 };
19443
19444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19445 if (obj0) {
19446 {
19447 arg1 = (wxEventType)(SWIG_As_int(obj0));
19448 if (SWIG_arg_fail(1)) SWIG_fail;
19449 }
19450 }
19451 if (obj1) {
19452 {
19453 arg2 = (int)(SWIG_As_int(obj1));
19454 if (SWIG_arg_fail(2)) SWIG_fail;
19455 }
19456 }
19457 if (obj2) {
19458 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19459 if (SWIG_arg_fail(3)) SWIG_fail;
19460 }
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19464
19465 wxPyEndAllowThreads(__tstate);
19466 if (PyErr_Occurred()) SWIG_fail;
19467 }
19468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19469 return resultobj;
19470 fail:
19471 return NULL;
19472 }
19473
19474
19475 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19476 PyObject *resultobj;
19477 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19478 int result;
19479 PyObject * obj0 = 0 ;
19480 char *kwnames[] = {
19481 (char *) "self", NULL
19482 };
19483
19484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19486 if (SWIG_arg_fail(1)) SWIG_fail;
19487 {
19488 PyThreadState* __tstate = wxPyBeginAllowThreads();
19489 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19490
19491 wxPyEndAllowThreads(__tstate);
19492 if (PyErr_Occurred()) SWIG_fail;
19493 }
19494 {
19495 resultobj = SWIG_From_int((int)(result));
19496 }
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19504 PyObject *resultobj;
19505 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19506 bool result;
19507 PyObject * obj0 = 0 ;
19508 char *kwnames[] = {
19509 (char *) "self", NULL
19510 };
19511
19512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19514 if (SWIG_arg_fail(1)) SWIG_fail;
19515 {
19516 PyThreadState* __tstate = wxPyBeginAllowThreads();
19517 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19518
19519 wxPyEndAllowThreads(__tstate);
19520 if (PyErr_Occurred()) SWIG_fail;
19521 }
19522 {
19523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19524 }
19525 return resultobj;
19526 fail:
19527 return NULL;
19528 }
19529
19530
19531 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19532 PyObject *resultobj;
19533 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19534 wxMenu *result;
19535 PyObject * obj0 = 0 ;
19536 char *kwnames[] = {
19537 (char *) "self", NULL
19538 };
19539
19540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19542 if (SWIG_arg_fail(1)) SWIG_fail;
19543 {
19544 PyThreadState* __tstate = wxPyBeginAllowThreads();
19545 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19546
19547 wxPyEndAllowThreads(__tstate);
19548 if (PyErr_Occurred()) SWIG_fail;
19549 }
19550 {
19551 resultobj = wxPyMake_wxObject(result, 0);
19552 }
19553 return resultobj;
19554 fail:
19555 return NULL;
19556 }
19557
19558
19559 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19560 PyObject *obj;
19561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19562 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19563 Py_INCREF(obj);
19564 return Py_BuildValue((char *)"");
19565 }
19566 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19567 PyObject *resultobj;
19568 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19569 int arg2 = (int) 0 ;
19570 wxCloseEvent *result;
19571 PyObject * obj0 = 0 ;
19572 PyObject * obj1 = 0 ;
19573 char *kwnames[] = {
19574 (char *) "type",(char *) "winid", NULL
19575 };
19576
19577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19578 if (obj0) {
19579 {
19580 arg1 = (wxEventType)(SWIG_As_int(obj0));
19581 if (SWIG_arg_fail(1)) SWIG_fail;
19582 }
19583 }
19584 if (obj1) {
19585 {
19586 arg2 = (int)(SWIG_As_int(obj1));
19587 if (SWIG_arg_fail(2)) SWIG_fail;
19588 }
19589 }
19590 {
19591 PyThreadState* __tstate = wxPyBeginAllowThreads();
19592 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19593
19594 wxPyEndAllowThreads(__tstate);
19595 if (PyErr_Occurred()) SWIG_fail;
19596 }
19597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19598 return resultobj;
19599 fail:
19600 return NULL;
19601 }
19602
19603
19604 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19605 PyObject *resultobj;
19606 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19607 bool arg2 ;
19608 PyObject * obj0 = 0 ;
19609 PyObject * obj1 = 0 ;
19610 char *kwnames[] = {
19611 (char *) "self",(char *) "logOff", NULL
19612 };
19613
19614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19616 if (SWIG_arg_fail(1)) SWIG_fail;
19617 {
19618 arg2 = (bool)(SWIG_As_bool(obj1));
19619 if (SWIG_arg_fail(2)) SWIG_fail;
19620 }
19621 {
19622 PyThreadState* __tstate = wxPyBeginAllowThreads();
19623 (arg1)->SetLoggingOff(arg2);
19624
19625 wxPyEndAllowThreads(__tstate);
19626 if (PyErr_Occurred()) SWIG_fail;
19627 }
19628 Py_INCREF(Py_None); resultobj = Py_None;
19629 return resultobj;
19630 fail:
19631 return NULL;
19632 }
19633
19634
19635 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19636 PyObject *resultobj;
19637 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19638 bool result;
19639 PyObject * obj0 = 0 ;
19640 char *kwnames[] = {
19641 (char *) "self", NULL
19642 };
19643
19644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19646 if (SWIG_arg_fail(1)) SWIG_fail;
19647 {
19648 PyThreadState* __tstate = wxPyBeginAllowThreads();
19649 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19650
19651 wxPyEndAllowThreads(__tstate);
19652 if (PyErr_Occurred()) SWIG_fail;
19653 }
19654 {
19655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19656 }
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19664 PyObject *resultobj;
19665 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19666 bool arg2 = (bool) true ;
19667 PyObject * obj0 = 0 ;
19668 PyObject * obj1 = 0 ;
19669 char *kwnames[] = {
19670 (char *) "self",(char *) "veto", NULL
19671 };
19672
19673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19675 if (SWIG_arg_fail(1)) SWIG_fail;
19676 if (obj1) {
19677 {
19678 arg2 = (bool)(SWIG_As_bool(obj1));
19679 if (SWIG_arg_fail(2)) SWIG_fail;
19680 }
19681 }
19682 {
19683 PyThreadState* __tstate = wxPyBeginAllowThreads();
19684 (arg1)->Veto(arg2);
19685
19686 wxPyEndAllowThreads(__tstate);
19687 if (PyErr_Occurred()) SWIG_fail;
19688 }
19689 Py_INCREF(Py_None); resultobj = Py_None;
19690 return resultobj;
19691 fail:
19692 return NULL;
19693 }
19694
19695
19696 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19697 PyObject *resultobj;
19698 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19699 bool arg2 ;
19700 PyObject * obj0 = 0 ;
19701 PyObject * obj1 = 0 ;
19702 char *kwnames[] = {
19703 (char *) "self",(char *) "canVeto", NULL
19704 };
19705
19706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19708 if (SWIG_arg_fail(1)) SWIG_fail;
19709 {
19710 arg2 = (bool)(SWIG_As_bool(obj1));
19711 if (SWIG_arg_fail(2)) SWIG_fail;
19712 }
19713 {
19714 PyThreadState* __tstate = wxPyBeginAllowThreads();
19715 (arg1)->SetCanVeto(arg2);
19716
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 Py_INCREF(Py_None); resultobj = Py_None;
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19728 PyObject *resultobj;
19729 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19730 bool result;
19731 PyObject * obj0 = 0 ;
19732 char *kwnames[] = {
19733 (char *) "self", NULL
19734 };
19735
19736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19738 if (SWIG_arg_fail(1)) SWIG_fail;
19739 {
19740 PyThreadState* __tstate = wxPyBeginAllowThreads();
19741 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19742
19743 wxPyEndAllowThreads(__tstate);
19744 if (PyErr_Occurred()) SWIG_fail;
19745 }
19746 {
19747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19748 }
19749 return resultobj;
19750 fail:
19751 return NULL;
19752 }
19753
19754
19755 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19756 PyObject *resultobj;
19757 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19758 bool result;
19759 PyObject * obj0 = 0 ;
19760 char *kwnames[] = {
19761 (char *) "self", NULL
19762 };
19763
19764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19766 if (SWIG_arg_fail(1)) SWIG_fail;
19767 {
19768 PyThreadState* __tstate = wxPyBeginAllowThreads();
19769 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19770
19771 wxPyEndAllowThreads(__tstate);
19772 if (PyErr_Occurred()) SWIG_fail;
19773 }
19774 {
19775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19776 }
19777 return resultobj;
19778 fail:
19779 return NULL;
19780 }
19781
19782
19783 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19784 PyObject *obj;
19785 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19786 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19787 Py_INCREF(obj);
19788 return Py_BuildValue((char *)"");
19789 }
19790 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19791 PyObject *resultobj;
19792 int arg1 = (int) 0 ;
19793 bool arg2 = (bool) false ;
19794 wxShowEvent *result;
19795 PyObject * obj0 = 0 ;
19796 PyObject * obj1 = 0 ;
19797 char *kwnames[] = {
19798 (char *) "winid",(char *) "show", NULL
19799 };
19800
19801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19802 if (obj0) {
19803 {
19804 arg1 = (int)(SWIG_As_int(obj0));
19805 if (SWIG_arg_fail(1)) SWIG_fail;
19806 }
19807 }
19808 if (obj1) {
19809 {
19810 arg2 = (bool)(SWIG_As_bool(obj1));
19811 if (SWIG_arg_fail(2)) SWIG_fail;
19812 }
19813 }
19814 {
19815 PyThreadState* __tstate = wxPyBeginAllowThreads();
19816 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
19817
19818 wxPyEndAllowThreads(__tstate);
19819 if (PyErr_Occurred()) SWIG_fail;
19820 }
19821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
19822 return resultobj;
19823 fail:
19824 return NULL;
19825 }
19826
19827
19828 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19829 PyObject *resultobj;
19830 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19831 bool arg2 ;
19832 PyObject * obj0 = 0 ;
19833 PyObject * obj1 = 0 ;
19834 char *kwnames[] = {
19835 (char *) "self",(char *) "show", NULL
19836 };
19837
19838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
19839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19840 if (SWIG_arg_fail(1)) SWIG_fail;
19841 {
19842 arg2 = (bool)(SWIG_As_bool(obj1));
19843 if (SWIG_arg_fail(2)) SWIG_fail;
19844 }
19845 {
19846 PyThreadState* __tstate = wxPyBeginAllowThreads();
19847 (arg1)->SetShow(arg2);
19848
19849 wxPyEndAllowThreads(__tstate);
19850 if (PyErr_Occurred()) SWIG_fail;
19851 }
19852 Py_INCREF(Py_None); resultobj = Py_None;
19853 return resultobj;
19854 fail:
19855 return NULL;
19856 }
19857
19858
19859 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19860 PyObject *resultobj;
19861 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19862 bool result;
19863 PyObject * obj0 = 0 ;
19864 char *kwnames[] = {
19865 (char *) "self", NULL
19866 };
19867
19868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
19869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19870 if (SWIG_arg_fail(1)) SWIG_fail;
19871 {
19872 PyThreadState* __tstate = wxPyBeginAllowThreads();
19873 result = (bool)((wxShowEvent const *)arg1)->GetShow();
19874
19875 wxPyEndAllowThreads(__tstate);
19876 if (PyErr_Occurred()) SWIG_fail;
19877 }
19878 {
19879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19880 }
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
19888 PyObject *obj;
19889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19890 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
19891 Py_INCREF(obj);
19892 return Py_BuildValue((char *)"");
19893 }
19894 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19895 PyObject *resultobj;
19896 int arg1 = (int) 0 ;
19897 bool arg2 = (bool) true ;
19898 wxIconizeEvent *result;
19899 PyObject * obj0 = 0 ;
19900 PyObject * obj1 = 0 ;
19901 char *kwnames[] = {
19902 (char *) "id",(char *) "iconized", NULL
19903 };
19904
19905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
19906 if (obj0) {
19907 {
19908 arg1 = (int)(SWIG_As_int(obj0));
19909 if (SWIG_arg_fail(1)) SWIG_fail;
19910 }
19911 }
19912 if (obj1) {
19913 {
19914 arg2 = (bool)(SWIG_As_bool(obj1));
19915 if (SWIG_arg_fail(2)) SWIG_fail;
19916 }
19917 }
19918 {
19919 PyThreadState* __tstate = wxPyBeginAllowThreads();
19920 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
19921
19922 wxPyEndAllowThreads(__tstate);
19923 if (PyErr_Occurred()) SWIG_fail;
19924 }
19925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
19926 return resultobj;
19927 fail:
19928 return NULL;
19929 }
19930
19931
19932 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
19933 PyObject *resultobj;
19934 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
19935 bool result;
19936 PyObject * obj0 = 0 ;
19937 char *kwnames[] = {
19938 (char *) "self", NULL
19939 };
19940
19941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
19942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
19943 if (SWIG_arg_fail(1)) SWIG_fail;
19944 {
19945 PyThreadState* __tstate = wxPyBeginAllowThreads();
19946 result = (bool)(arg1)->Iconized();
19947
19948 wxPyEndAllowThreads(__tstate);
19949 if (PyErr_Occurred()) SWIG_fail;
19950 }
19951 {
19952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19953 }
19954 return resultobj;
19955 fail:
19956 return NULL;
19957 }
19958
19959
19960 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
19961 PyObject *obj;
19962 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19963 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
19964 Py_INCREF(obj);
19965 return Py_BuildValue((char *)"");
19966 }
19967 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19968 PyObject *resultobj;
19969 int arg1 = (int) 0 ;
19970 wxMaximizeEvent *result;
19971 PyObject * obj0 = 0 ;
19972 char *kwnames[] = {
19973 (char *) "id", NULL
19974 };
19975
19976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
19977 if (obj0) {
19978 {
19979 arg1 = (int)(SWIG_As_int(obj0));
19980 if (SWIG_arg_fail(1)) SWIG_fail;
19981 }
19982 }
19983 {
19984 PyThreadState* __tstate = wxPyBeginAllowThreads();
19985 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
19986
19987 wxPyEndAllowThreads(__tstate);
19988 if (PyErr_Occurred()) SWIG_fail;
19989 }
19990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
19991 return resultobj;
19992 fail:
19993 return NULL;
19994 }
19995
19996
19997 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
19998 PyObject *obj;
19999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20000 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20001 Py_INCREF(obj);
20002 return Py_BuildValue((char *)"");
20003 }
20004 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20005 PyObject *resultobj;
20006 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20007 wxPoint result;
20008 PyObject * obj0 = 0 ;
20009 char *kwnames[] = {
20010 (char *) "self", NULL
20011 };
20012
20013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20015 if (SWIG_arg_fail(1)) SWIG_fail;
20016 {
20017 PyThreadState* __tstate = wxPyBeginAllowThreads();
20018 result = (arg1)->GetPosition();
20019
20020 wxPyEndAllowThreads(__tstate);
20021 if (PyErr_Occurred()) SWIG_fail;
20022 }
20023 {
20024 wxPoint * resultptr;
20025 resultptr = new wxPoint((wxPoint &)(result));
20026 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20027 }
20028 return resultobj;
20029 fail:
20030 return NULL;
20031 }
20032
20033
20034 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20035 PyObject *resultobj;
20036 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20037 int result;
20038 PyObject * obj0 = 0 ;
20039 char *kwnames[] = {
20040 (char *) "self", NULL
20041 };
20042
20043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20045 if (SWIG_arg_fail(1)) SWIG_fail;
20046 {
20047 PyThreadState* __tstate = wxPyBeginAllowThreads();
20048 result = (int)(arg1)->GetNumberOfFiles();
20049
20050 wxPyEndAllowThreads(__tstate);
20051 if (PyErr_Occurred()) SWIG_fail;
20052 }
20053 {
20054 resultobj = SWIG_From_int((int)(result));
20055 }
20056 return resultobj;
20057 fail:
20058 return NULL;
20059 }
20060
20061
20062 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20063 PyObject *resultobj;
20064 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20065 PyObject *result;
20066 PyObject * obj0 = 0 ;
20067 char *kwnames[] = {
20068 (char *) "self", NULL
20069 };
20070
20071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20073 if (SWIG_arg_fail(1)) SWIG_fail;
20074 {
20075 PyThreadState* __tstate = wxPyBeginAllowThreads();
20076 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20077
20078 wxPyEndAllowThreads(__tstate);
20079 if (PyErr_Occurred()) SWIG_fail;
20080 }
20081 resultobj = result;
20082 return resultobj;
20083 fail:
20084 return NULL;
20085 }
20086
20087
20088 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20089 PyObject *obj;
20090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20091 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20092 Py_INCREF(obj);
20093 return Py_BuildValue((char *)"");
20094 }
20095 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20096 PyObject *resultobj;
20097 int arg1 = (int) 0 ;
20098 wxUpdateUIEvent *result;
20099 PyObject * obj0 = 0 ;
20100 char *kwnames[] = {
20101 (char *) "commandId", NULL
20102 };
20103
20104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",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 = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20114
20115 wxPyEndAllowThreads(__tstate);
20116 if (PyErr_Occurred()) SWIG_fail;
20117 }
20118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20119 return resultobj;
20120 fail:
20121 return NULL;
20122 }
20123
20124
20125 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20126 PyObject *resultobj;
20127 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20128 bool result;
20129 PyObject * obj0 = 0 ;
20130 char *kwnames[] = {
20131 (char *) "self", NULL
20132 };
20133
20134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20136 if (SWIG_arg_fail(1)) SWIG_fail;
20137 {
20138 PyThreadState* __tstate = wxPyBeginAllowThreads();
20139 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20140
20141 wxPyEndAllowThreads(__tstate);
20142 if (PyErr_Occurred()) SWIG_fail;
20143 }
20144 {
20145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20146 }
20147 return resultobj;
20148 fail:
20149 return NULL;
20150 }
20151
20152
20153 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20154 PyObject *resultobj;
20155 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20156 bool result;
20157 PyObject * obj0 = 0 ;
20158 char *kwnames[] = {
20159 (char *) "self", NULL
20160 };
20161
20162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20164 if (SWIG_arg_fail(1)) SWIG_fail;
20165 {
20166 PyThreadState* __tstate = wxPyBeginAllowThreads();
20167 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20168
20169 wxPyEndAllowThreads(__tstate);
20170 if (PyErr_Occurred()) SWIG_fail;
20171 }
20172 {
20173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20174 }
20175 return resultobj;
20176 fail:
20177 return NULL;
20178 }
20179
20180
20181 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20182 PyObject *resultobj;
20183 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20184 wxString result;
20185 PyObject * obj0 = 0 ;
20186 char *kwnames[] = {
20187 (char *) "self", NULL
20188 };
20189
20190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20192 if (SWIG_arg_fail(1)) SWIG_fail;
20193 {
20194 PyThreadState* __tstate = wxPyBeginAllowThreads();
20195 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20196
20197 wxPyEndAllowThreads(__tstate);
20198 if (PyErr_Occurred()) SWIG_fail;
20199 }
20200 {
20201 #if wxUSE_UNICODE
20202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20203 #else
20204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20205 #endif
20206 }
20207 return resultobj;
20208 fail:
20209 return NULL;
20210 }
20211
20212
20213 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20214 PyObject *resultobj;
20215 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20216 bool result;
20217 PyObject * obj0 = 0 ;
20218 char *kwnames[] = {
20219 (char *) "self", NULL
20220 };
20221
20222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20224 if (SWIG_arg_fail(1)) SWIG_fail;
20225 {
20226 PyThreadState* __tstate = wxPyBeginAllowThreads();
20227 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20228
20229 wxPyEndAllowThreads(__tstate);
20230 if (PyErr_Occurred()) SWIG_fail;
20231 }
20232 {
20233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20234 }
20235 return resultobj;
20236 fail:
20237 return NULL;
20238 }
20239
20240
20241 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20242 PyObject *resultobj;
20243 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20244 bool result;
20245 PyObject * obj0 = 0 ;
20246 char *kwnames[] = {
20247 (char *) "self", NULL
20248 };
20249
20250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20252 if (SWIG_arg_fail(1)) SWIG_fail;
20253 {
20254 PyThreadState* __tstate = wxPyBeginAllowThreads();
20255 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20256
20257 wxPyEndAllowThreads(__tstate);
20258 if (PyErr_Occurred()) SWIG_fail;
20259 }
20260 {
20261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20262 }
20263 return resultobj;
20264 fail:
20265 return NULL;
20266 }
20267
20268
20269 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20270 PyObject *resultobj;
20271 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20272 bool result;
20273 PyObject * obj0 = 0 ;
20274 char *kwnames[] = {
20275 (char *) "self", NULL
20276 };
20277
20278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20280 if (SWIG_arg_fail(1)) SWIG_fail;
20281 {
20282 PyThreadState* __tstate = wxPyBeginAllowThreads();
20283 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20284
20285 wxPyEndAllowThreads(__tstate);
20286 if (PyErr_Occurred()) SWIG_fail;
20287 }
20288 {
20289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20290 }
20291 return resultobj;
20292 fail:
20293 return NULL;
20294 }
20295
20296
20297 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20298 PyObject *resultobj;
20299 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20300 bool arg2 ;
20301 PyObject * obj0 = 0 ;
20302 PyObject * obj1 = 0 ;
20303 char *kwnames[] = {
20304 (char *) "self",(char *) "check", NULL
20305 };
20306
20307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20309 if (SWIG_arg_fail(1)) SWIG_fail;
20310 {
20311 arg2 = (bool)(SWIG_As_bool(obj1));
20312 if (SWIG_arg_fail(2)) SWIG_fail;
20313 }
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 (arg1)->Check(arg2);
20317
20318 wxPyEndAllowThreads(__tstate);
20319 if (PyErr_Occurred()) SWIG_fail;
20320 }
20321 Py_INCREF(Py_None); resultobj = Py_None;
20322 return resultobj;
20323 fail:
20324 return NULL;
20325 }
20326
20327
20328 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20329 PyObject *resultobj;
20330 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20331 bool arg2 ;
20332 PyObject * obj0 = 0 ;
20333 PyObject * obj1 = 0 ;
20334 char *kwnames[] = {
20335 (char *) "self",(char *) "enable", NULL
20336 };
20337
20338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20340 if (SWIG_arg_fail(1)) SWIG_fail;
20341 {
20342 arg2 = (bool)(SWIG_As_bool(obj1));
20343 if (SWIG_arg_fail(2)) SWIG_fail;
20344 }
20345 {
20346 PyThreadState* __tstate = wxPyBeginAllowThreads();
20347 (arg1)->Enable(arg2);
20348
20349 wxPyEndAllowThreads(__tstate);
20350 if (PyErr_Occurred()) SWIG_fail;
20351 }
20352 Py_INCREF(Py_None); resultobj = Py_None;
20353 return resultobj;
20354 fail:
20355 return NULL;
20356 }
20357
20358
20359 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20360 PyObject *resultobj;
20361 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20362 wxString *arg2 = 0 ;
20363 bool temp2 = false ;
20364 PyObject * obj0 = 0 ;
20365 PyObject * obj1 = 0 ;
20366 char *kwnames[] = {
20367 (char *) "self",(char *) "text", NULL
20368 };
20369
20370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20372 if (SWIG_arg_fail(1)) SWIG_fail;
20373 {
20374 arg2 = wxString_in_helper(obj1);
20375 if (arg2 == NULL) SWIG_fail;
20376 temp2 = true;
20377 }
20378 {
20379 PyThreadState* __tstate = wxPyBeginAllowThreads();
20380 (arg1)->SetText((wxString const &)*arg2);
20381
20382 wxPyEndAllowThreads(__tstate);
20383 if (PyErr_Occurred()) SWIG_fail;
20384 }
20385 Py_INCREF(Py_None); resultobj = Py_None;
20386 {
20387 if (temp2)
20388 delete arg2;
20389 }
20390 return resultobj;
20391 fail:
20392 {
20393 if (temp2)
20394 delete arg2;
20395 }
20396 return NULL;
20397 }
20398
20399
20400 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20401 PyObject *resultobj;
20402 long arg1 ;
20403 PyObject * obj0 = 0 ;
20404 char *kwnames[] = {
20405 (char *) "updateInterval", NULL
20406 };
20407
20408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20409 {
20410 arg1 = (long)(SWIG_As_long(obj0));
20411 if (SWIG_arg_fail(1)) SWIG_fail;
20412 }
20413 {
20414 PyThreadState* __tstate = wxPyBeginAllowThreads();
20415 wxUpdateUIEvent::SetUpdateInterval(arg1);
20416
20417 wxPyEndAllowThreads(__tstate);
20418 if (PyErr_Occurred()) SWIG_fail;
20419 }
20420 Py_INCREF(Py_None); resultobj = Py_None;
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20428 PyObject *resultobj;
20429 long result;
20430 char *kwnames[] = {
20431 NULL
20432 };
20433
20434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20435 {
20436 PyThreadState* __tstate = wxPyBeginAllowThreads();
20437 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20438
20439 wxPyEndAllowThreads(__tstate);
20440 if (PyErr_Occurred()) SWIG_fail;
20441 }
20442 {
20443 resultobj = SWIG_From_long((long)(result));
20444 }
20445 return resultobj;
20446 fail:
20447 return NULL;
20448 }
20449
20450
20451 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20452 PyObject *resultobj;
20453 wxWindow *arg1 = (wxWindow *) 0 ;
20454 bool result;
20455 PyObject * obj0 = 0 ;
20456 char *kwnames[] = {
20457 (char *) "win", NULL
20458 };
20459
20460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20462 if (SWIG_arg_fail(1)) SWIG_fail;
20463 {
20464 PyThreadState* __tstate = wxPyBeginAllowThreads();
20465 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
20466
20467 wxPyEndAllowThreads(__tstate);
20468 if (PyErr_Occurred()) SWIG_fail;
20469 }
20470 {
20471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20472 }
20473 return resultobj;
20474 fail:
20475 return NULL;
20476 }
20477
20478
20479 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20480 PyObject *resultobj;
20481 char *kwnames[] = {
20482 NULL
20483 };
20484
20485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20486 {
20487 PyThreadState* __tstate = wxPyBeginAllowThreads();
20488 wxUpdateUIEvent::ResetUpdateTime();
20489
20490 wxPyEndAllowThreads(__tstate);
20491 if (PyErr_Occurred()) SWIG_fail;
20492 }
20493 Py_INCREF(Py_None); resultobj = Py_None;
20494 return resultobj;
20495 fail:
20496 return NULL;
20497 }
20498
20499
20500 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20501 PyObject *resultobj;
20502 wxUpdateUIMode arg1 ;
20503 PyObject * obj0 = 0 ;
20504 char *kwnames[] = {
20505 (char *) "mode", NULL
20506 };
20507
20508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20509 {
20510 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20511 if (SWIG_arg_fail(1)) SWIG_fail;
20512 }
20513 {
20514 PyThreadState* __tstate = wxPyBeginAllowThreads();
20515 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20516
20517 wxPyEndAllowThreads(__tstate);
20518 if (PyErr_Occurred()) SWIG_fail;
20519 }
20520 Py_INCREF(Py_None); resultobj = Py_None;
20521 return resultobj;
20522 fail:
20523 return NULL;
20524 }
20525
20526
20527 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20528 PyObject *resultobj;
20529 wxUpdateUIMode result;
20530 char *kwnames[] = {
20531 NULL
20532 };
20533
20534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20535 {
20536 PyThreadState* __tstate = wxPyBeginAllowThreads();
20537 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20538
20539 wxPyEndAllowThreads(__tstate);
20540 if (PyErr_Occurred()) SWIG_fail;
20541 }
20542 resultobj = SWIG_From_int((result));
20543 return resultobj;
20544 fail:
20545 return NULL;
20546 }
20547
20548
20549 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20550 PyObject *obj;
20551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20552 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20553 Py_INCREF(obj);
20554 return Py_BuildValue((char *)"");
20555 }
20556 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20557 PyObject *resultobj;
20558 wxSysColourChangedEvent *result;
20559 char *kwnames[] = {
20560 NULL
20561 };
20562
20563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20564 {
20565 PyThreadState* __tstate = wxPyBeginAllowThreads();
20566 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20567
20568 wxPyEndAllowThreads(__tstate);
20569 if (PyErr_Occurred()) SWIG_fail;
20570 }
20571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20572 return resultobj;
20573 fail:
20574 return NULL;
20575 }
20576
20577
20578 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20579 PyObject *obj;
20580 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20581 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20582 Py_INCREF(obj);
20583 return Py_BuildValue((char *)"");
20584 }
20585 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20586 PyObject *resultobj;
20587 int arg1 = (int) 0 ;
20588 wxWindow *arg2 = (wxWindow *) NULL ;
20589 wxMouseCaptureChangedEvent *result;
20590 PyObject * obj0 = 0 ;
20591 PyObject * obj1 = 0 ;
20592 char *kwnames[] = {
20593 (char *) "winid",(char *) "gainedCapture", NULL
20594 };
20595
20596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20597 if (obj0) {
20598 {
20599 arg1 = (int)(SWIG_As_int(obj0));
20600 if (SWIG_arg_fail(1)) SWIG_fail;
20601 }
20602 }
20603 if (obj1) {
20604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20605 if (SWIG_arg_fail(2)) SWIG_fail;
20606 }
20607 {
20608 PyThreadState* __tstate = wxPyBeginAllowThreads();
20609 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20610
20611 wxPyEndAllowThreads(__tstate);
20612 if (PyErr_Occurred()) SWIG_fail;
20613 }
20614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20615 return resultobj;
20616 fail:
20617 return NULL;
20618 }
20619
20620
20621 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20622 PyObject *resultobj;
20623 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20624 wxWindow *result;
20625 PyObject * obj0 = 0 ;
20626 char *kwnames[] = {
20627 (char *) "self", NULL
20628 };
20629
20630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20632 if (SWIG_arg_fail(1)) SWIG_fail;
20633 {
20634 PyThreadState* __tstate = wxPyBeginAllowThreads();
20635 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20636
20637 wxPyEndAllowThreads(__tstate);
20638 if (PyErr_Occurred()) SWIG_fail;
20639 }
20640 {
20641 resultobj = wxPyMake_wxObject(result, 0);
20642 }
20643 return resultobj;
20644 fail:
20645 return NULL;
20646 }
20647
20648
20649 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20650 PyObject *obj;
20651 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20652 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20653 Py_INCREF(obj);
20654 return Py_BuildValue((char *)"");
20655 }
20656 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20657 PyObject *resultobj;
20658 wxDisplayChangedEvent *result;
20659 char *kwnames[] = {
20660 NULL
20661 };
20662
20663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20664 {
20665 PyThreadState* __tstate = wxPyBeginAllowThreads();
20666 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20667
20668 wxPyEndAllowThreads(__tstate);
20669 if (PyErr_Occurred()) SWIG_fail;
20670 }
20671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20672 return resultobj;
20673 fail:
20674 return NULL;
20675 }
20676
20677
20678 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20679 PyObject *obj;
20680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20681 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20682 Py_INCREF(obj);
20683 return Py_BuildValue((char *)"");
20684 }
20685 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20686 PyObject *resultobj;
20687 int arg1 = (int) 0 ;
20688 wxPaletteChangedEvent *result;
20689 PyObject * obj0 = 0 ;
20690 char *kwnames[] = {
20691 (char *) "id", NULL
20692 };
20693
20694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20695 if (obj0) {
20696 {
20697 arg1 = (int)(SWIG_As_int(obj0));
20698 if (SWIG_arg_fail(1)) SWIG_fail;
20699 }
20700 }
20701 {
20702 PyThreadState* __tstate = wxPyBeginAllowThreads();
20703 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20704
20705 wxPyEndAllowThreads(__tstate);
20706 if (PyErr_Occurred()) SWIG_fail;
20707 }
20708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20709 return resultobj;
20710 fail:
20711 return NULL;
20712 }
20713
20714
20715 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20716 PyObject *resultobj;
20717 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20718 wxWindow *arg2 = (wxWindow *) 0 ;
20719 PyObject * obj0 = 0 ;
20720 PyObject * obj1 = 0 ;
20721 char *kwnames[] = {
20722 (char *) "self",(char *) "win", NULL
20723 };
20724
20725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20727 if (SWIG_arg_fail(1)) SWIG_fail;
20728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20729 if (SWIG_arg_fail(2)) SWIG_fail;
20730 {
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 (arg1)->SetChangedWindow(arg2);
20733
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 Py_INCREF(Py_None); resultobj = Py_None;
20738 return resultobj;
20739 fail:
20740 return NULL;
20741 }
20742
20743
20744 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20745 PyObject *resultobj;
20746 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20747 wxWindow *result;
20748 PyObject * obj0 = 0 ;
20749 char *kwnames[] = {
20750 (char *) "self", NULL
20751 };
20752
20753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20755 if (SWIG_arg_fail(1)) SWIG_fail;
20756 {
20757 PyThreadState* __tstate = wxPyBeginAllowThreads();
20758 result = (wxWindow *)(arg1)->GetChangedWindow();
20759
20760 wxPyEndAllowThreads(__tstate);
20761 if (PyErr_Occurred()) SWIG_fail;
20762 }
20763 {
20764 resultobj = wxPyMake_wxObject(result, 0);
20765 }
20766 return resultobj;
20767 fail:
20768 return NULL;
20769 }
20770
20771
20772 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20773 PyObject *obj;
20774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20775 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20776 Py_INCREF(obj);
20777 return Py_BuildValue((char *)"");
20778 }
20779 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20780 PyObject *resultobj;
20781 int arg1 = (int) 0 ;
20782 wxQueryNewPaletteEvent *result;
20783 PyObject * obj0 = 0 ;
20784 char *kwnames[] = {
20785 (char *) "winid", NULL
20786 };
20787
20788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20789 if (obj0) {
20790 {
20791 arg1 = (int)(SWIG_As_int(obj0));
20792 if (SWIG_arg_fail(1)) SWIG_fail;
20793 }
20794 }
20795 {
20796 PyThreadState* __tstate = wxPyBeginAllowThreads();
20797 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20798
20799 wxPyEndAllowThreads(__tstate);
20800 if (PyErr_Occurred()) SWIG_fail;
20801 }
20802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20803 return resultobj;
20804 fail:
20805 return NULL;
20806 }
20807
20808
20809 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20810 PyObject *resultobj;
20811 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20812 bool arg2 ;
20813 PyObject * obj0 = 0 ;
20814 PyObject * obj1 = 0 ;
20815 char *kwnames[] = {
20816 (char *) "self",(char *) "realized", NULL
20817 };
20818
20819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
20820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20821 if (SWIG_arg_fail(1)) SWIG_fail;
20822 {
20823 arg2 = (bool)(SWIG_As_bool(obj1));
20824 if (SWIG_arg_fail(2)) SWIG_fail;
20825 }
20826 {
20827 PyThreadState* __tstate = wxPyBeginAllowThreads();
20828 (arg1)->SetPaletteRealized(arg2);
20829
20830 wxPyEndAllowThreads(__tstate);
20831 if (PyErr_Occurred()) SWIG_fail;
20832 }
20833 Py_INCREF(Py_None); resultobj = Py_None;
20834 return resultobj;
20835 fail:
20836 return NULL;
20837 }
20838
20839
20840 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20841 PyObject *resultobj;
20842 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20843 bool result;
20844 PyObject * obj0 = 0 ;
20845 char *kwnames[] = {
20846 (char *) "self", NULL
20847 };
20848
20849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
20850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20851 if (SWIG_arg_fail(1)) SWIG_fail;
20852 {
20853 PyThreadState* __tstate = wxPyBeginAllowThreads();
20854 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
20855
20856 wxPyEndAllowThreads(__tstate);
20857 if (PyErr_Occurred()) SWIG_fail;
20858 }
20859 {
20860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20861 }
20862 return resultobj;
20863 fail:
20864 return NULL;
20865 }
20866
20867
20868 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
20869 PyObject *obj;
20870 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20871 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
20872 Py_INCREF(obj);
20873 return Py_BuildValue((char *)"");
20874 }
20875 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20876 PyObject *resultobj;
20877 wxNavigationKeyEvent *result;
20878 char *kwnames[] = {
20879 NULL
20880 };
20881
20882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
20883 {
20884 PyThreadState* __tstate = wxPyBeginAllowThreads();
20885 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
20886
20887 wxPyEndAllowThreads(__tstate);
20888 if (PyErr_Occurred()) SWIG_fail;
20889 }
20890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
20898 PyObject *resultobj;
20899 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20900 bool result;
20901 PyObject * obj0 = 0 ;
20902 char *kwnames[] = {
20903 (char *) "self", NULL
20904 };
20905
20906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
20907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20908 if (SWIG_arg_fail(1)) SWIG_fail;
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
20912
20913 wxPyEndAllowThreads(__tstate);
20914 if (PyErr_Occurred()) SWIG_fail;
20915 }
20916 {
20917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20918 }
20919 return resultobj;
20920 fail:
20921 return NULL;
20922 }
20923
20924
20925 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
20926 PyObject *resultobj;
20927 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20928 bool arg2 ;
20929 PyObject * obj0 = 0 ;
20930 PyObject * obj1 = 0 ;
20931 char *kwnames[] = {
20932 (char *) "self",(char *) "forward", NULL
20933 };
20934
20935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
20936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20937 if (SWIG_arg_fail(1)) SWIG_fail;
20938 {
20939 arg2 = (bool)(SWIG_As_bool(obj1));
20940 if (SWIG_arg_fail(2)) SWIG_fail;
20941 }
20942 {
20943 PyThreadState* __tstate = wxPyBeginAllowThreads();
20944 (arg1)->SetDirection(arg2);
20945
20946 wxPyEndAllowThreads(__tstate);
20947 if (PyErr_Occurred()) SWIG_fail;
20948 }
20949 Py_INCREF(Py_None); resultobj = Py_None;
20950 return resultobj;
20951 fail:
20952 return NULL;
20953 }
20954
20955
20956 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
20957 PyObject *resultobj;
20958 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20959 bool result;
20960 PyObject * obj0 = 0 ;
20961 char *kwnames[] = {
20962 (char *) "self", NULL
20963 };
20964
20965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
20966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20967 if (SWIG_arg_fail(1)) SWIG_fail;
20968 {
20969 PyThreadState* __tstate = wxPyBeginAllowThreads();
20970 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
20971
20972 wxPyEndAllowThreads(__tstate);
20973 if (PyErr_Occurred()) SWIG_fail;
20974 }
20975 {
20976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20977 }
20978 return resultobj;
20979 fail:
20980 return NULL;
20981 }
20982
20983
20984 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
20985 PyObject *resultobj;
20986 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
20987 bool arg2 ;
20988 PyObject * obj0 = 0 ;
20989 PyObject * obj1 = 0 ;
20990 char *kwnames[] = {
20991 (char *) "self",(char *) "ischange", NULL
20992 };
20993
20994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
20995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20996 if (SWIG_arg_fail(1)) SWIG_fail;
20997 {
20998 arg2 = (bool)(SWIG_As_bool(obj1));
20999 if (SWIG_arg_fail(2)) SWIG_fail;
21000 }
21001 {
21002 PyThreadState* __tstate = wxPyBeginAllowThreads();
21003 (arg1)->SetWindowChange(arg2);
21004
21005 wxPyEndAllowThreads(__tstate);
21006 if (PyErr_Occurred()) SWIG_fail;
21007 }
21008 Py_INCREF(Py_None); resultobj = Py_None;
21009 return resultobj;
21010 fail:
21011 return NULL;
21012 }
21013
21014
21015 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21016 PyObject *resultobj;
21017 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21018 long arg2 ;
21019 PyObject * obj0 = 0 ;
21020 PyObject * obj1 = 0 ;
21021 char *kwnames[] = {
21022 (char *) "self",(char *) "flags", NULL
21023 };
21024
21025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21027 if (SWIG_arg_fail(1)) SWIG_fail;
21028 {
21029 arg2 = (long)(SWIG_As_long(obj1));
21030 if (SWIG_arg_fail(2)) SWIG_fail;
21031 }
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 (arg1)->SetFlags(arg2);
21035
21036 wxPyEndAllowThreads(__tstate);
21037 if (PyErr_Occurred()) SWIG_fail;
21038 }
21039 Py_INCREF(Py_None); resultobj = Py_None;
21040 return resultobj;
21041 fail:
21042 return NULL;
21043 }
21044
21045
21046 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21047 PyObject *resultobj;
21048 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21049 wxWindow *result;
21050 PyObject * obj0 = 0 ;
21051 char *kwnames[] = {
21052 (char *) "self", NULL
21053 };
21054
21055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21057 if (SWIG_arg_fail(1)) SWIG_fail;
21058 {
21059 PyThreadState* __tstate = wxPyBeginAllowThreads();
21060 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21061
21062 wxPyEndAllowThreads(__tstate);
21063 if (PyErr_Occurred()) SWIG_fail;
21064 }
21065 {
21066 resultobj = wxPyMake_wxObject(result, 0);
21067 }
21068 return resultobj;
21069 fail:
21070 return NULL;
21071 }
21072
21073
21074 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21075 PyObject *resultobj;
21076 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21077 wxWindow *arg2 = (wxWindow *) 0 ;
21078 PyObject * obj0 = 0 ;
21079 PyObject * obj1 = 0 ;
21080 char *kwnames[] = {
21081 (char *) "self",(char *) "win", NULL
21082 };
21083
21084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21086 if (SWIG_arg_fail(1)) SWIG_fail;
21087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21088 if (SWIG_arg_fail(2)) SWIG_fail;
21089 {
21090 PyThreadState* __tstate = wxPyBeginAllowThreads();
21091 (arg1)->SetCurrentFocus(arg2);
21092
21093 wxPyEndAllowThreads(__tstate);
21094 if (PyErr_Occurred()) SWIG_fail;
21095 }
21096 Py_INCREF(Py_None); resultobj = Py_None;
21097 return resultobj;
21098 fail:
21099 return NULL;
21100 }
21101
21102
21103 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21104 PyObject *obj;
21105 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21106 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21107 Py_INCREF(obj);
21108 return Py_BuildValue((char *)"");
21109 }
21110 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21111 PyObject *resultobj;
21112 wxWindow *arg1 = (wxWindow *) NULL ;
21113 wxWindowCreateEvent *result;
21114 PyObject * obj0 = 0 ;
21115 char *kwnames[] = {
21116 (char *) "win", NULL
21117 };
21118
21119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21120 if (obj0) {
21121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21122 if (SWIG_arg_fail(1)) SWIG_fail;
21123 }
21124 {
21125 PyThreadState* __tstate = wxPyBeginAllowThreads();
21126 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21127
21128 wxPyEndAllowThreads(__tstate);
21129 if (PyErr_Occurred()) SWIG_fail;
21130 }
21131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21132 return resultobj;
21133 fail:
21134 return NULL;
21135 }
21136
21137
21138 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21139 PyObject *resultobj;
21140 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21141 wxWindow *result;
21142 PyObject * obj0 = 0 ;
21143 char *kwnames[] = {
21144 (char *) "self", NULL
21145 };
21146
21147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21149 if (SWIG_arg_fail(1)) SWIG_fail;
21150 {
21151 PyThreadState* __tstate = wxPyBeginAllowThreads();
21152 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21153
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 {
21158 resultobj = wxPyMake_wxObject(result, 0);
21159 }
21160 return resultobj;
21161 fail:
21162 return NULL;
21163 }
21164
21165
21166 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21167 PyObject *obj;
21168 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21169 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21170 Py_INCREF(obj);
21171 return Py_BuildValue((char *)"");
21172 }
21173 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21174 PyObject *resultobj;
21175 wxWindow *arg1 = (wxWindow *) NULL ;
21176 wxWindowDestroyEvent *result;
21177 PyObject * obj0 = 0 ;
21178 char *kwnames[] = {
21179 (char *) "win", NULL
21180 };
21181
21182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21183 if (obj0) {
21184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21185 if (SWIG_arg_fail(1)) SWIG_fail;
21186 }
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21190
21191 wxPyEndAllowThreads(__tstate);
21192 if (PyErr_Occurred()) SWIG_fail;
21193 }
21194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21195 return resultobj;
21196 fail:
21197 return NULL;
21198 }
21199
21200
21201 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21202 PyObject *resultobj;
21203 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21204 wxWindow *result;
21205 PyObject * obj0 = 0 ;
21206 char *kwnames[] = {
21207 (char *) "self", NULL
21208 };
21209
21210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21212 if (SWIG_arg_fail(1)) SWIG_fail;
21213 {
21214 PyThreadState* __tstate = wxPyBeginAllowThreads();
21215 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21216
21217 wxPyEndAllowThreads(__tstate);
21218 if (PyErr_Occurred()) SWIG_fail;
21219 }
21220 {
21221 resultobj = wxPyMake_wxObject(result, 0);
21222 }
21223 return resultobj;
21224 fail:
21225 return NULL;
21226 }
21227
21228
21229 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21230 PyObject *obj;
21231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21232 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21233 Py_INCREF(obj);
21234 return Py_BuildValue((char *)"");
21235 }
21236 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21237 PyObject *resultobj;
21238 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21239 int arg2 = (int) 0 ;
21240 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21241 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21242 wxContextMenuEvent *result;
21243 wxPoint temp3 ;
21244 PyObject * obj0 = 0 ;
21245 PyObject * obj1 = 0 ;
21246 PyObject * obj2 = 0 ;
21247 char *kwnames[] = {
21248 (char *) "type",(char *) "winid",(char *) "pt", NULL
21249 };
21250
21251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21252 if (obj0) {
21253 {
21254 arg1 = (wxEventType)(SWIG_As_int(obj0));
21255 if (SWIG_arg_fail(1)) SWIG_fail;
21256 }
21257 }
21258 if (obj1) {
21259 {
21260 arg2 = (int)(SWIG_As_int(obj1));
21261 if (SWIG_arg_fail(2)) SWIG_fail;
21262 }
21263 }
21264 if (obj2) {
21265 {
21266 arg3 = &temp3;
21267 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21268 }
21269 }
21270 {
21271 PyThreadState* __tstate = wxPyBeginAllowThreads();
21272 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21273
21274 wxPyEndAllowThreads(__tstate);
21275 if (PyErr_Occurred()) SWIG_fail;
21276 }
21277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21278 return resultobj;
21279 fail:
21280 return NULL;
21281 }
21282
21283
21284 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21285 PyObject *resultobj;
21286 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21287 wxPoint *result;
21288 PyObject * obj0 = 0 ;
21289 char *kwnames[] = {
21290 (char *) "self", NULL
21291 };
21292
21293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21295 if (SWIG_arg_fail(1)) SWIG_fail;
21296 {
21297 PyThreadState* __tstate = wxPyBeginAllowThreads();
21298 {
21299 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21300 result = (wxPoint *) &_result_ref;
21301 }
21302
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21314 PyObject *resultobj;
21315 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21316 wxPoint *arg2 = 0 ;
21317 wxPoint temp2 ;
21318 PyObject * obj0 = 0 ;
21319 PyObject * obj1 = 0 ;
21320 char *kwnames[] = {
21321 (char *) "self",(char *) "pos", NULL
21322 };
21323
21324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21326 if (SWIG_arg_fail(1)) SWIG_fail;
21327 {
21328 arg2 = &temp2;
21329 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21330 }
21331 {
21332 PyThreadState* __tstate = wxPyBeginAllowThreads();
21333 (arg1)->SetPosition((wxPoint const &)*arg2);
21334
21335 wxPyEndAllowThreads(__tstate);
21336 if (PyErr_Occurred()) SWIG_fail;
21337 }
21338 Py_INCREF(Py_None); resultobj = Py_None;
21339 return resultobj;
21340 fail:
21341 return NULL;
21342 }
21343
21344
21345 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21346 PyObject *obj;
21347 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21348 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21349 Py_INCREF(obj);
21350 return Py_BuildValue((char *)"");
21351 }
21352 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21353 PyObject *resultobj;
21354 wxIdleEvent *result;
21355 char *kwnames[] = {
21356 NULL
21357 };
21358
21359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21360 {
21361 PyThreadState* __tstate = wxPyBeginAllowThreads();
21362 result = (wxIdleEvent *)new wxIdleEvent();
21363
21364 wxPyEndAllowThreads(__tstate);
21365 if (PyErr_Occurred()) SWIG_fail;
21366 }
21367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21368 return resultobj;
21369 fail:
21370 return NULL;
21371 }
21372
21373
21374 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21375 PyObject *resultobj;
21376 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21377 bool arg2 = (bool) true ;
21378 PyObject * obj0 = 0 ;
21379 PyObject * obj1 = 0 ;
21380 char *kwnames[] = {
21381 (char *) "self",(char *) "needMore", NULL
21382 };
21383
21384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21386 if (SWIG_arg_fail(1)) SWIG_fail;
21387 if (obj1) {
21388 {
21389 arg2 = (bool)(SWIG_As_bool(obj1));
21390 if (SWIG_arg_fail(2)) SWIG_fail;
21391 }
21392 }
21393 {
21394 PyThreadState* __tstate = wxPyBeginAllowThreads();
21395 (arg1)->RequestMore(arg2);
21396
21397 wxPyEndAllowThreads(__tstate);
21398 if (PyErr_Occurred()) SWIG_fail;
21399 }
21400 Py_INCREF(Py_None); resultobj = Py_None;
21401 return resultobj;
21402 fail:
21403 return NULL;
21404 }
21405
21406
21407 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21408 PyObject *resultobj;
21409 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21410 bool result;
21411 PyObject * obj0 = 0 ;
21412 char *kwnames[] = {
21413 (char *) "self", NULL
21414 };
21415
21416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21418 if (SWIG_arg_fail(1)) SWIG_fail;
21419 {
21420 PyThreadState* __tstate = wxPyBeginAllowThreads();
21421 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21422
21423 wxPyEndAllowThreads(__tstate);
21424 if (PyErr_Occurred()) SWIG_fail;
21425 }
21426 {
21427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21428 }
21429 return resultobj;
21430 fail:
21431 return NULL;
21432 }
21433
21434
21435 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21436 PyObject *resultobj;
21437 wxIdleMode arg1 ;
21438 PyObject * obj0 = 0 ;
21439 char *kwnames[] = {
21440 (char *) "mode", NULL
21441 };
21442
21443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21444 {
21445 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21446 if (SWIG_arg_fail(1)) SWIG_fail;
21447 }
21448 {
21449 PyThreadState* __tstate = wxPyBeginAllowThreads();
21450 wxIdleEvent::SetMode((wxIdleMode )arg1);
21451
21452 wxPyEndAllowThreads(__tstate);
21453 if (PyErr_Occurred()) SWIG_fail;
21454 }
21455 Py_INCREF(Py_None); resultobj = Py_None;
21456 return resultobj;
21457 fail:
21458 return NULL;
21459 }
21460
21461
21462 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21463 PyObject *resultobj;
21464 wxIdleMode result;
21465 char *kwnames[] = {
21466 NULL
21467 };
21468
21469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21470 {
21471 PyThreadState* __tstate = wxPyBeginAllowThreads();
21472 result = (wxIdleMode)wxIdleEvent::GetMode();
21473
21474 wxPyEndAllowThreads(__tstate);
21475 if (PyErr_Occurred()) SWIG_fail;
21476 }
21477 resultobj = SWIG_From_int((result));
21478 return resultobj;
21479 fail:
21480 return NULL;
21481 }
21482
21483
21484 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21485 PyObject *resultobj;
21486 wxWindow *arg1 = (wxWindow *) 0 ;
21487 bool result;
21488 PyObject * obj0 = 0 ;
21489 char *kwnames[] = {
21490 (char *) "win", NULL
21491 };
21492
21493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21495 if (SWIG_arg_fail(1)) SWIG_fail;
21496 {
21497 PyThreadState* __tstate = wxPyBeginAllowThreads();
21498 result = (bool)wxIdleEvent::CanSend(arg1);
21499
21500 wxPyEndAllowThreads(__tstate);
21501 if (PyErr_Occurred()) SWIG_fail;
21502 }
21503 {
21504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21505 }
21506 return resultobj;
21507 fail:
21508 return NULL;
21509 }
21510
21511
21512 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21513 PyObject *obj;
21514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21515 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21516 Py_INCREF(obj);
21517 return Py_BuildValue((char *)"");
21518 }
21519 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21520 PyObject *resultobj;
21521 int arg1 = (int) 0 ;
21522 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21523 wxPyEvent *result;
21524 PyObject * obj0 = 0 ;
21525 PyObject * obj1 = 0 ;
21526 char *kwnames[] = {
21527 (char *) "winid",(char *) "commandType", NULL
21528 };
21529
21530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21531 if (obj0) {
21532 {
21533 arg1 = (int)(SWIG_As_int(obj0));
21534 if (SWIG_arg_fail(1)) SWIG_fail;
21535 }
21536 }
21537 if (obj1) {
21538 {
21539 arg2 = (wxEventType)(SWIG_As_int(obj1));
21540 if (SWIG_arg_fail(2)) SWIG_fail;
21541 }
21542 }
21543 {
21544 PyThreadState* __tstate = wxPyBeginAllowThreads();
21545 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21546
21547 wxPyEndAllowThreads(__tstate);
21548 if (PyErr_Occurred()) SWIG_fail;
21549 }
21550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21558 PyObject *resultobj;
21559 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21560 PyObject * obj0 = 0 ;
21561 char *kwnames[] = {
21562 (char *) "self", NULL
21563 };
21564
21565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21567 if (SWIG_arg_fail(1)) SWIG_fail;
21568 {
21569 PyThreadState* __tstate = wxPyBeginAllowThreads();
21570 delete arg1;
21571
21572 wxPyEndAllowThreads(__tstate);
21573 if (PyErr_Occurred()) SWIG_fail;
21574 }
21575 Py_INCREF(Py_None); resultobj = Py_None;
21576 return resultobj;
21577 fail:
21578 return NULL;
21579 }
21580
21581
21582 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21583 PyObject *resultobj;
21584 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21585 PyObject *arg2 = (PyObject *) 0 ;
21586 PyObject * obj0 = 0 ;
21587 PyObject * obj1 = 0 ;
21588 char *kwnames[] = {
21589 (char *) "self",(char *) "self", NULL
21590 };
21591
21592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21594 if (SWIG_arg_fail(1)) SWIG_fail;
21595 arg2 = obj1;
21596 {
21597 PyThreadState* __tstate = wxPyBeginAllowThreads();
21598 (arg1)->SetSelf(arg2);
21599
21600 wxPyEndAllowThreads(__tstate);
21601 if (PyErr_Occurred()) SWIG_fail;
21602 }
21603 Py_INCREF(Py_None); resultobj = Py_None;
21604 return resultobj;
21605 fail:
21606 return NULL;
21607 }
21608
21609
21610 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21611 PyObject *resultobj;
21612 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21613 PyObject *result;
21614 PyObject * obj0 = 0 ;
21615 char *kwnames[] = {
21616 (char *) "self", NULL
21617 };
21618
21619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21621 if (SWIG_arg_fail(1)) SWIG_fail;
21622 {
21623 PyThreadState* __tstate = wxPyBeginAllowThreads();
21624 result = (PyObject *)(arg1)->GetSelf();
21625
21626 wxPyEndAllowThreads(__tstate);
21627 if (PyErr_Occurred()) SWIG_fail;
21628 }
21629 resultobj = result;
21630 return resultobj;
21631 fail:
21632 return NULL;
21633 }
21634
21635
21636 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21637 PyObject *obj;
21638 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21639 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21640 Py_INCREF(obj);
21641 return Py_BuildValue((char *)"");
21642 }
21643 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21644 PyObject *resultobj;
21645 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21646 int arg2 = (int) 0 ;
21647 wxPyCommandEvent *result;
21648 PyObject * obj0 = 0 ;
21649 PyObject * obj1 = 0 ;
21650 char *kwnames[] = {
21651 (char *) "commandType",(char *) "id", NULL
21652 };
21653
21654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21655 if (obj0) {
21656 {
21657 arg1 = (wxEventType)(SWIG_As_int(obj0));
21658 if (SWIG_arg_fail(1)) SWIG_fail;
21659 }
21660 }
21661 if (obj1) {
21662 {
21663 arg2 = (int)(SWIG_As_int(obj1));
21664 if (SWIG_arg_fail(2)) SWIG_fail;
21665 }
21666 }
21667 {
21668 PyThreadState* __tstate = wxPyBeginAllowThreads();
21669 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21670
21671 wxPyEndAllowThreads(__tstate);
21672 if (PyErr_Occurred()) SWIG_fail;
21673 }
21674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21675 return resultobj;
21676 fail:
21677 return NULL;
21678 }
21679
21680
21681 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21682 PyObject *resultobj;
21683 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21684 PyObject * obj0 = 0 ;
21685 char *kwnames[] = {
21686 (char *) "self", NULL
21687 };
21688
21689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21691 if (SWIG_arg_fail(1)) SWIG_fail;
21692 {
21693 PyThreadState* __tstate = wxPyBeginAllowThreads();
21694 delete arg1;
21695
21696 wxPyEndAllowThreads(__tstate);
21697 if (PyErr_Occurred()) SWIG_fail;
21698 }
21699 Py_INCREF(Py_None); resultobj = Py_None;
21700 return resultobj;
21701 fail:
21702 return NULL;
21703 }
21704
21705
21706 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21707 PyObject *resultobj;
21708 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21709 PyObject *arg2 = (PyObject *) 0 ;
21710 PyObject * obj0 = 0 ;
21711 PyObject * obj1 = 0 ;
21712 char *kwnames[] = {
21713 (char *) "self",(char *) "self", NULL
21714 };
21715
21716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21718 if (SWIG_arg_fail(1)) SWIG_fail;
21719 arg2 = obj1;
21720 {
21721 PyThreadState* __tstate = wxPyBeginAllowThreads();
21722 (arg1)->SetSelf(arg2);
21723
21724 wxPyEndAllowThreads(__tstate);
21725 if (PyErr_Occurred()) SWIG_fail;
21726 }
21727 Py_INCREF(Py_None); resultobj = Py_None;
21728 return resultobj;
21729 fail:
21730 return NULL;
21731 }
21732
21733
21734 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21735 PyObject *resultobj;
21736 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21737 PyObject *result;
21738 PyObject * obj0 = 0 ;
21739 char *kwnames[] = {
21740 (char *) "self", NULL
21741 };
21742
21743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21745 if (SWIG_arg_fail(1)) SWIG_fail;
21746 {
21747 PyThreadState* __tstate = wxPyBeginAllowThreads();
21748 result = (PyObject *)(arg1)->GetSelf();
21749
21750 wxPyEndAllowThreads(__tstate);
21751 if (PyErr_Occurred()) SWIG_fail;
21752 }
21753 resultobj = result;
21754 return resultobj;
21755 fail:
21756 return NULL;
21757 }
21758
21759
21760 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
21761 PyObject *obj;
21762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21763 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
21764 Py_INCREF(obj);
21765 return Py_BuildValue((char *)"");
21766 }
21767 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21768 PyObject *resultobj;
21769 wxPyApp *result;
21770 char *kwnames[] = {
21771 NULL
21772 };
21773
21774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 result = (wxPyApp *)new_wxPyApp();
21778
21779 wxPyEndAllowThreads(__tstate);
21780 if (PyErr_Occurred()) SWIG_fail;
21781 }
21782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
21783 return resultobj;
21784 fail:
21785 return NULL;
21786 }
21787
21788
21789 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
21790 PyObject *resultobj;
21791 wxPyApp *arg1 = (wxPyApp *) 0 ;
21792 PyObject * obj0 = 0 ;
21793 char *kwnames[] = {
21794 (char *) "self", NULL
21795 };
21796
21797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
21798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21799 if (SWIG_arg_fail(1)) SWIG_fail;
21800 {
21801 PyThreadState* __tstate = wxPyBeginAllowThreads();
21802 delete arg1;
21803
21804 wxPyEndAllowThreads(__tstate);
21805 if (PyErr_Occurred()) SWIG_fail;
21806 }
21807 Py_INCREF(Py_None); resultobj = Py_None;
21808 return resultobj;
21809 fail:
21810 return NULL;
21811 }
21812
21813
21814 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
21815 PyObject *resultobj;
21816 wxPyApp *arg1 = (wxPyApp *) 0 ;
21817 PyObject *arg2 = (PyObject *) 0 ;
21818 PyObject *arg3 = (PyObject *) 0 ;
21819 PyObject * obj0 = 0 ;
21820 PyObject * obj1 = 0 ;
21821 PyObject * obj2 = 0 ;
21822 char *kwnames[] = {
21823 (char *) "self",(char *) "self",(char *) "_class", NULL
21824 };
21825
21826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
21827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21828 if (SWIG_arg_fail(1)) SWIG_fail;
21829 arg2 = obj1;
21830 arg3 = obj2;
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 (arg1)->_setCallbackInfo(arg2,arg3);
21834
21835 wxPyEndAllowThreads(__tstate);
21836 if (PyErr_Occurred()) SWIG_fail;
21837 }
21838 Py_INCREF(Py_None); resultobj = Py_None;
21839 return resultobj;
21840 fail:
21841 return NULL;
21842 }
21843
21844
21845 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21846 PyObject *resultobj;
21847 wxPyApp *arg1 = (wxPyApp *) 0 ;
21848 wxString result;
21849 PyObject * obj0 = 0 ;
21850 char *kwnames[] = {
21851 (char *) "self", NULL
21852 };
21853
21854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
21855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21856 if (SWIG_arg_fail(1)) SWIG_fail;
21857 {
21858 PyThreadState* __tstate = wxPyBeginAllowThreads();
21859 result = ((wxPyApp const *)arg1)->GetAppName();
21860
21861 wxPyEndAllowThreads(__tstate);
21862 if (PyErr_Occurred()) SWIG_fail;
21863 }
21864 {
21865 #if wxUSE_UNICODE
21866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21867 #else
21868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21869 #endif
21870 }
21871 return resultobj;
21872 fail:
21873 return NULL;
21874 }
21875
21876
21877 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
21878 PyObject *resultobj;
21879 wxPyApp *arg1 = (wxPyApp *) 0 ;
21880 wxString *arg2 = 0 ;
21881 bool temp2 = false ;
21882 PyObject * obj0 = 0 ;
21883 PyObject * obj1 = 0 ;
21884 char *kwnames[] = {
21885 (char *) "self",(char *) "name", NULL
21886 };
21887
21888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
21889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21890 if (SWIG_arg_fail(1)) SWIG_fail;
21891 {
21892 arg2 = wxString_in_helper(obj1);
21893 if (arg2 == NULL) SWIG_fail;
21894 temp2 = true;
21895 }
21896 {
21897 PyThreadState* __tstate = wxPyBeginAllowThreads();
21898 (arg1)->SetAppName((wxString const &)*arg2);
21899
21900 wxPyEndAllowThreads(__tstate);
21901 if (PyErr_Occurred()) SWIG_fail;
21902 }
21903 Py_INCREF(Py_None); resultobj = Py_None;
21904 {
21905 if (temp2)
21906 delete arg2;
21907 }
21908 return resultobj;
21909 fail:
21910 {
21911 if (temp2)
21912 delete arg2;
21913 }
21914 return NULL;
21915 }
21916
21917
21918 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
21919 PyObject *resultobj;
21920 wxPyApp *arg1 = (wxPyApp *) 0 ;
21921 wxString result;
21922 PyObject * obj0 = 0 ;
21923 char *kwnames[] = {
21924 (char *) "self", NULL
21925 };
21926
21927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
21928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21929 if (SWIG_arg_fail(1)) SWIG_fail;
21930 {
21931 PyThreadState* __tstate = wxPyBeginAllowThreads();
21932 result = ((wxPyApp const *)arg1)->GetClassName();
21933
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 {
21938 #if wxUSE_UNICODE
21939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21940 #else
21941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21942 #endif
21943 }
21944 return resultobj;
21945 fail:
21946 return NULL;
21947 }
21948
21949
21950 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
21951 PyObject *resultobj;
21952 wxPyApp *arg1 = (wxPyApp *) 0 ;
21953 wxString *arg2 = 0 ;
21954 bool temp2 = false ;
21955 PyObject * obj0 = 0 ;
21956 PyObject * obj1 = 0 ;
21957 char *kwnames[] = {
21958 (char *) "self",(char *) "name", NULL
21959 };
21960
21961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
21962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
21963 if (SWIG_arg_fail(1)) SWIG_fail;
21964 {
21965 arg2 = wxString_in_helper(obj1);
21966 if (arg2 == NULL) SWIG_fail;
21967 temp2 = true;
21968 }
21969 {
21970 PyThreadState* __tstate = wxPyBeginAllowThreads();
21971 (arg1)->SetClassName((wxString const &)*arg2);
21972
21973 wxPyEndAllowThreads(__tstate);
21974 if (PyErr_Occurred()) SWIG_fail;
21975 }
21976 Py_INCREF(Py_None); resultobj = Py_None;
21977 {
21978 if (temp2)
21979 delete arg2;
21980 }
21981 return resultobj;
21982 fail:
21983 {
21984 if (temp2)
21985 delete arg2;
21986 }
21987 return NULL;
21988 }
21989
21990
21991 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
21992 PyObject *resultobj;
21993 wxPyApp *arg1 = (wxPyApp *) 0 ;
21994 wxString *result;
21995 PyObject * obj0 = 0 ;
21996 char *kwnames[] = {
21997 (char *) "self", NULL
21998 };
21999
22000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22002 if (SWIG_arg_fail(1)) SWIG_fail;
22003 {
22004 PyThreadState* __tstate = wxPyBeginAllowThreads();
22005 {
22006 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22007 result = (wxString *) &_result_ref;
22008 }
22009
22010 wxPyEndAllowThreads(__tstate);
22011 if (PyErr_Occurred()) SWIG_fail;
22012 }
22013 {
22014 #if wxUSE_UNICODE
22015 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22016 #else
22017 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22018 #endif
22019 }
22020 return resultobj;
22021 fail:
22022 return NULL;
22023 }
22024
22025
22026 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22027 PyObject *resultobj;
22028 wxPyApp *arg1 = (wxPyApp *) 0 ;
22029 wxString *arg2 = 0 ;
22030 bool temp2 = false ;
22031 PyObject * obj0 = 0 ;
22032 PyObject * obj1 = 0 ;
22033 char *kwnames[] = {
22034 (char *) "self",(char *) "name", NULL
22035 };
22036
22037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22039 if (SWIG_arg_fail(1)) SWIG_fail;
22040 {
22041 arg2 = wxString_in_helper(obj1);
22042 if (arg2 == NULL) SWIG_fail;
22043 temp2 = true;
22044 }
22045 {
22046 PyThreadState* __tstate = wxPyBeginAllowThreads();
22047 (arg1)->SetVendorName((wxString const &)*arg2);
22048
22049 wxPyEndAllowThreads(__tstate);
22050 if (PyErr_Occurred()) SWIG_fail;
22051 }
22052 Py_INCREF(Py_None); resultobj = Py_None;
22053 {
22054 if (temp2)
22055 delete arg2;
22056 }
22057 return resultobj;
22058 fail:
22059 {
22060 if (temp2)
22061 delete arg2;
22062 }
22063 return NULL;
22064 }
22065
22066
22067 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22068 PyObject *resultobj;
22069 wxPyApp *arg1 = (wxPyApp *) 0 ;
22070 wxAppTraits *result;
22071 PyObject * obj0 = 0 ;
22072 char *kwnames[] = {
22073 (char *) "self", NULL
22074 };
22075
22076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22078 if (SWIG_arg_fail(1)) SWIG_fail;
22079 {
22080 PyThreadState* __tstate = wxPyBeginAllowThreads();
22081 result = (wxAppTraits *)(arg1)->GetTraits();
22082
22083 wxPyEndAllowThreads(__tstate);
22084 if (PyErr_Occurred()) SWIG_fail;
22085 }
22086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22087 return resultobj;
22088 fail:
22089 return NULL;
22090 }
22091
22092
22093 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22094 PyObject *resultobj;
22095 wxPyApp *arg1 = (wxPyApp *) 0 ;
22096 PyObject * obj0 = 0 ;
22097 char *kwnames[] = {
22098 (char *) "self", NULL
22099 };
22100
22101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22103 if (SWIG_arg_fail(1)) SWIG_fail;
22104 {
22105 PyThreadState* __tstate = wxPyBeginAllowThreads();
22106 (arg1)->ProcessPendingEvents();
22107
22108 wxPyEndAllowThreads(__tstate);
22109 if (PyErr_Occurred()) SWIG_fail;
22110 }
22111 Py_INCREF(Py_None); resultobj = Py_None;
22112 return resultobj;
22113 fail:
22114 return NULL;
22115 }
22116
22117
22118 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22119 PyObject *resultobj;
22120 wxPyApp *arg1 = (wxPyApp *) 0 ;
22121 bool arg2 = (bool) false ;
22122 bool result;
22123 PyObject * obj0 = 0 ;
22124 PyObject * obj1 = 0 ;
22125 char *kwnames[] = {
22126 (char *) "self",(char *) "onlyIfNeeded", NULL
22127 };
22128
22129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22131 if (SWIG_arg_fail(1)) SWIG_fail;
22132 if (obj1) {
22133 {
22134 arg2 = (bool)(SWIG_As_bool(obj1));
22135 if (SWIG_arg_fail(2)) SWIG_fail;
22136 }
22137 }
22138 {
22139 PyThreadState* __tstate = wxPyBeginAllowThreads();
22140 result = (bool)(arg1)->Yield(arg2);
22141
22142 wxPyEndAllowThreads(__tstate);
22143 if (PyErr_Occurred()) SWIG_fail;
22144 }
22145 {
22146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22147 }
22148 return resultobj;
22149 fail:
22150 return NULL;
22151 }
22152
22153
22154 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22155 PyObject *resultobj;
22156 wxPyApp *arg1 = (wxPyApp *) 0 ;
22157 PyObject * obj0 = 0 ;
22158 char *kwnames[] = {
22159 (char *) "self", NULL
22160 };
22161
22162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22164 if (SWIG_arg_fail(1)) SWIG_fail;
22165 {
22166 PyThreadState* __tstate = wxPyBeginAllowThreads();
22167 (arg1)->WakeUpIdle();
22168
22169 wxPyEndAllowThreads(__tstate);
22170 if (PyErr_Occurred()) SWIG_fail;
22171 }
22172 Py_INCREF(Py_None); resultobj = Py_None;
22173 return resultobj;
22174 fail:
22175 return NULL;
22176 }
22177
22178
22179 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22180 PyObject *resultobj;
22181 bool result;
22182 char *kwnames[] = {
22183 NULL
22184 };
22185
22186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22187 {
22188 PyThreadState* __tstate = wxPyBeginAllowThreads();
22189 result = (bool)wxPyApp::IsMainLoopRunning();
22190
22191 wxPyEndAllowThreads(__tstate);
22192 if (PyErr_Occurred()) SWIG_fail;
22193 }
22194 {
22195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22196 }
22197 return resultobj;
22198 fail:
22199 return NULL;
22200 }
22201
22202
22203 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22204 PyObject *resultobj;
22205 wxPyApp *arg1 = (wxPyApp *) 0 ;
22206 int result;
22207 PyObject * obj0 = 0 ;
22208 char *kwnames[] = {
22209 (char *) "self", NULL
22210 };
22211
22212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22214 if (SWIG_arg_fail(1)) SWIG_fail;
22215 {
22216 PyThreadState* __tstate = wxPyBeginAllowThreads();
22217 result = (int)(arg1)->MainLoop();
22218
22219 wxPyEndAllowThreads(__tstate);
22220 if (PyErr_Occurred()) SWIG_fail;
22221 }
22222 {
22223 resultobj = SWIG_From_int((int)(result));
22224 }
22225 return resultobj;
22226 fail:
22227 return NULL;
22228 }
22229
22230
22231 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22232 PyObject *resultobj;
22233 wxPyApp *arg1 = (wxPyApp *) 0 ;
22234 PyObject * obj0 = 0 ;
22235 char *kwnames[] = {
22236 (char *) "self", NULL
22237 };
22238
22239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22241 if (SWIG_arg_fail(1)) SWIG_fail;
22242 {
22243 PyThreadState* __tstate = wxPyBeginAllowThreads();
22244 (arg1)->Exit();
22245
22246 wxPyEndAllowThreads(__tstate);
22247 if (PyErr_Occurred()) SWIG_fail;
22248 }
22249 Py_INCREF(Py_None); resultobj = Py_None;
22250 return resultobj;
22251 fail:
22252 return NULL;
22253 }
22254
22255
22256 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22257 PyObject *resultobj;
22258 wxPyApp *arg1 = (wxPyApp *) 0 ;
22259 PyObject * obj0 = 0 ;
22260 char *kwnames[] = {
22261 (char *) "self", NULL
22262 };
22263
22264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22266 if (SWIG_arg_fail(1)) SWIG_fail;
22267 {
22268 PyThreadState* __tstate = wxPyBeginAllowThreads();
22269 (arg1)->ExitMainLoop();
22270
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 Py_INCREF(Py_None); resultobj = Py_None;
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22282 PyObject *resultobj;
22283 wxPyApp *arg1 = (wxPyApp *) 0 ;
22284 bool result;
22285 PyObject * obj0 = 0 ;
22286 char *kwnames[] = {
22287 (char *) "self", NULL
22288 };
22289
22290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22292 if (SWIG_arg_fail(1)) SWIG_fail;
22293 {
22294 PyThreadState* __tstate = wxPyBeginAllowThreads();
22295 result = (bool)(arg1)->Pending();
22296
22297 wxPyEndAllowThreads(__tstate);
22298 if (PyErr_Occurred()) SWIG_fail;
22299 }
22300 {
22301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22302 }
22303 return resultobj;
22304 fail:
22305 return NULL;
22306 }
22307
22308
22309 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22310 PyObject *resultobj;
22311 wxPyApp *arg1 = (wxPyApp *) 0 ;
22312 bool result;
22313 PyObject * obj0 = 0 ;
22314 char *kwnames[] = {
22315 (char *) "self", NULL
22316 };
22317
22318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22320 if (SWIG_arg_fail(1)) SWIG_fail;
22321 {
22322 PyThreadState* __tstate = wxPyBeginAllowThreads();
22323 result = (bool)(arg1)->Dispatch();
22324
22325 wxPyEndAllowThreads(__tstate);
22326 if (PyErr_Occurred()) SWIG_fail;
22327 }
22328 {
22329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22330 }
22331 return resultobj;
22332 fail:
22333 return NULL;
22334 }
22335
22336
22337 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22338 PyObject *resultobj;
22339 wxPyApp *arg1 = (wxPyApp *) 0 ;
22340 bool result;
22341 PyObject * obj0 = 0 ;
22342 char *kwnames[] = {
22343 (char *) "self", NULL
22344 };
22345
22346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22348 if (SWIG_arg_fail(1)) SWIG_fail;
22349 {
22350 PyThreadState* __tstate = wxPyBeginAllowThreads();
22351 result = (bool)(arg1)->ProcessIdle();
22352
22353 wxPyEndAllowThreads(__tstate);
22354 if (PyErr_Occurred()) SWIG_fail;
22355 }
22356 {
22357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22358 }
22359 return resultobj;
22360 fail:
22361 return NULL;
22362 }
22363
22364
22365 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22366 PyObject *resultobj;
22367 wxPyApp *arg1 = (wxPyApp *) 0 ;
22368 wxWindow *arg2 = (wxWindow *) 0 ;
22369 wxIdleEvent *arg3 = 0 ;
22370 bool result;
22371 PyObject * obj0 = 0 ;
22372 PyObject * obj1 = 0 ;
22373 PyObject * obj2 = 0 ;
22374 char *kwnames[] = {
22375 (char *) "self",(char *) "win",(char *) "event", NULL
22376 };
22377
22378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22380 if (SWIG_arg_fail(1)) SWIG_fail;
22381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22382 if (SWIG_arg_fail(2)) SWIG_fail;
22383 {
22384 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22385 if (SWIG_arg_fail(3)) SWIG_fail;
22386 if (arg3 == NULL) {
22387 SWIG_null_ref("wxIdleEvent");
22388 }
22389 if (SWIG_arg_fail(3)) SWIG_fail;
22390 }
22391 {
22392 PyThreadState* __tstate = wxPyBeginAllowThreads();
22393 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22394
22395 wxPyEndAllowThreads(__tstate);
22396 if (PyErr_Occurred()) SWIG_fail;
22397 }
22398 {
22399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22400 }
22401 return resultobj;
22402 fail:
22403 return NULL;
22404 }
22405
22406
22407 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22408 PyObject *resultobj;
22409 wxPyApp *arg1 = (wxPyApp *) 0 ;
22410 bool result;
22411 PyObject * obj0 = 0 ;
22412 char *kwnames[] = {
22413 (char *) "self", NULL
22414 };
22415
22416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22418 if (SWIG_arg_fail(1)) SWIG_fail;
22419 {
22420 PyThreadState* __tstate = wxPyBeginAllowThreads();
22421 result = (bool)((wxPyApp const *)arg1)->IsActive();
22422
22423 wxPyEndAllowThreads(__tstate);
22424 if (PyErr_Occurred()) SWIG_fail;
22425 }
22426 {
22427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22428 }
22429 return resultobj;
22430 fail:
22431 return NULL;
22432 }
22433
22434
22435 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22436 PyObject *resultobj;
22437 wxPyApp *arg1 = (wxPyApp *) 0 ;
22438 wxWindow *arg2 = (wxWindow *) 0 ;
22439 PyObject * obj0 = 0 ;
22440 PyObject * obj1 = 0 ;
22441 char *kwnames[] = {
22442 (char *) "self",(char *) "win", NULL
22443 };
22444
22445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22447 if (SWIG_arg_fail(1)) SWIG_fail;
22448 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22449 if (SWIG_arg_fail(2)) SWIG_fail;
22450 {
22451 PyThreadState* __tstate = wxPyBeginAllowThreads();
22452 (arg1)->SetTopWindow(arg2);
22453
22454 wxPyEndAllowThreads(__tstate);
22455 if (PyErr_Occurred()) SWIG_fail;
22456 }
22457 Py_INCREF(Py_None); resultobj = Py_None;
22458 return resultobj;
22459 fail:
22460 return NULL;
22461 }
22462
22463
22464 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22465 PyObject *resultobj;
22466 wxPyApp *arg1 = (wxPyApp *) 0 ;
22467 wxWindow *result;
22468 PyObject * obj0 = 0 ;
22469 char *kwnames[] = {
22470 (char *) "self", NULL
22471 };
22472
22473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22475 if (SWIG_arg_fail(1)) SWIG_fail;
22476 {
22477 PyThreadState* __tstate = wxPyBeginAllowThreads();
22478 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22479
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 {
22484 resultobj = wxPyMake_wxObject(result, 0);
22485 }
22486 return resultobj;
22487 fail:
22488 return NULL;
22489 }
22490
22491
22492 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22493 PyObject *resultobj;
22494 wxPyApp *arg1 = (wxPyApp *) 0 ;
22495 bool arg2 ;
22496 PyObject * obj0 = 0 ;
22497 PyObject * obj1 = 0 ;
22498 char *kwnames[] = {
22499 (char *) "self",(char *) "flag", NULL
22500 };
22501
22502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22504 if (SWIG_arg_fail(1)) SWIG_fail;
22505 {
22506 arg2 = (bool)(SWIG_As_bool(obj1));
22507 if (SWIG_arg_fail(2)) SWIG_fail;
22508 }
22509 {
22510 PyThreadState* __tstate = wxPyBeginAllowThreads();
22511 (arg1)->SetExitOnFrameDelete(arg2);
22512
22513 wxPyEndAllowThreads(__tstate);
22514 if (PyErr_Occurred()) SWIG_fail;
22515 }
22516 Py_INCREF(Py_None); resultobj = Py_None;
22517 return resultobj;
22518 fail:
22519 return NULL;
22520 }
22521
22522
22523 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22524 PyObject *resultobj;
22525 wxPyApp *arg1 = (wxPyApp *) 0 ;
22526 bool result;
22527 PyObject * obj0 = 0 ;
22528 char *kwnames[] = {
22529 (char *) "self", NULL
22530 };
22531
22532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22534 if (SWIG_arg_fail(1)) SWIG_fail;
22535 {
22536 PyThreadState* __tstate = wxPyBeginAllowThreads();
22537 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22538
22539 wxPyEndAllowThreads(__tstate);
22540 if (PyErr_Occurred()) SWIG_fail;
22541 }
22542 {
22543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22544 }
22545 return resultobj;
22546 fail:
22547 return NULL;
22548 }
22549
22550
22551 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22552 PyObject *resultobj;
22553 wxPyApp *arg1 = (wxPyApp *) 0 ;
22554 bool arg2 ;
22555 PyObject * obj0 = 0 ;
22556 PyObject * obj1 = 0 ;
22557 char *kwnames[] = {
22558 (char *) "self",(char *) "flag", NULL
22559 };
22560
22561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22563 if (SWIG_arg_fail(1)) SWIG_fail;
22564 {
22565 arg2 = (bool)(SWIG_As_bool(obj1));
22566 if (SWIG_arg_fail(2)) SWIG_fail;
22567 }
22568 {
22569 PyThreadState* __tstate = wxPyBeginAllowThreads();
22570 (arg1)->SetUseBestVisual(arg2);
22571
22572 wxPyEndAllowThreads(__tstate);
22573 if (PyErr_Occurred()) SWIG_fail;
22574 }
22575 Py_INCREF(Py_None); resultobj = Py_None;
22576 return resultobj;
22577 fail:
22578 return NULL;
22579 }
22580
22581
22582 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22583 PyObject *resultobj;
22584 wxPyApp *arg1 = (wxPyApp *) 0 ;
22585 bool result;
22586 PyObject * obj0 = 0 ;
22587 char *kwnames[] = {
22588 (char *) "self", NULL
22589 };
22590
22591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22593 if (SWIG_arg_fail(1)) SWIG_fail;
22594 {
22595 PyThreadState* __tstate = wxPyBeginAllowThreads();
22596 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22597
22598 wxPyEndAllowThreads(__tstate);
22599 if (PyErr_Occurred()) SWIG_fail;
22600 }
22601 {
22602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22603 }
22604 return resultobj;
22605 fail:
22606 return NULL;
22607 }
22608
22609
22610 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22611 PyObject *resultobj;
22612 wxPyApp *arg1 = (wxPyApp *) 0 ;
22613 int arg2 ;
22614 PyObject * obj0 = 0 ;
22615 PyObject * obj1 = 0 ;
22616 char *kwnames[] = {
22617 (char *) "self",(char *) "mode", NULL
22618 };
22619
22620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22622 if (SWIG_arg_fail(1)) SWIG_fail;
22623 {
22624 arg2 = (int)(SWIG_As_int(obj1));
22625 if (SWIG_arg_fail(2)) SWIG_fail;
22626 }
22627 {
22628 PyThreadState* __tstate = wxPyBeginAllowThreads();
22629 (arg1)->SetPrintMode(arg2);
22630
22631 wxPyEndAllowThreads(__tstate);
22632 if (PyErr_Occurred()) SWIG_fail;
22633 }
22634 Py_INCREF(Py_None); resultobj = Py_None;
22635 return resultobj;
22636 fail:
22637 return NULL;
22638 }
22639
22640
22641 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22642 PyObject *resultobj;
22643 wxPyApp *arg1 = (wxPyApp *) 0 ;
22644 int result;
22645 PyObject * obj0 = 0 ;
22646 char *kwnames[] = {
22647 (char *) "self", NULL
22648 };
22649
22650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
22651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22652 if (SWIG_arg_fail(1)) SWIG_fail;
22653 {
22654 PyThreadState* __tstate = wxPyBeginAllowThreads();
22655 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
22656
22657 wxPyEndAllowThreads(__tstate);
22658 if (PyErr_Occurred()) SWIG_fail;
22659 }
22660 {
22661 resultobj = SWIG_From_int((int)(result));
22662 }
22663 return resultobj;
22664 fail:
22665 return NULL;
22666 }
22667
22668
22669 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22670 PyObject *resultobj;
22671 wxPyApp *arg1 = (wxPyApp *) 0 ;
22672 int arg2 ;
22673 PyObject * obj0 = 0 ;
22674 PyObject * obj1 = 0 ;
22675 char *kwnames[] = {
22676 (char *) "self",(char *) "mode", NULL
22677 };
22678
22679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
22680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22681 if (SWIG_arg_fail(1)) SWIG_fail;
22682 {
22683 arg2 = (int)(SWIG_As_int(obj1));
22684 if (SWIG_arg_fail(2)) SWIG_fail;
22685 }
22686 {
22687 PyThreadState* __tstate = wxPyBeginAllowThreads();
22688 (arg1)->SetAssertMode(arg2);
22689
22690 wxPyEndAllowThreads(__tstate);
22691 if (PyErr_Occurred()) SWIG_fail;
22692 }
22693 Py_INCREF(Py_None); resultobj = Py_None;
22694 return resultobj;
22695 fail:
22696 return NULL;
22697 }
22698
22699
22700 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22701 PyObject *resultobj;
22702 wxPyApp *arg1 = (wxPyApp *) 0 ;
22703 int result;
22704 PyObject * obj0 = 0 ;
22705 char *kwnames[] = {
22706 (char *) "self", NULL
22707 };
22708
22709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
22710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22711 if (SWIG_arg_fail(1)) SWIG_fail;
22712 {
22713 PyThreadState* __tstate = wxPyBeginAllowThreads();
22714 result = (int)(arg1)->GetAssertMode();
22715
22716 wxPyEndAllowThreads(__tstate);
22717 if (PyErr_Occurred()) SWIG_fail;
22718 }
22719 {
22720 resultobj = SWIG_From_int((int)(result));
22721 }
22722 return resultobj;
22723 fail:
22724 return NULL;
22725 }
22726
22727
22728 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22729 PyObject *resultobj;
22730 bool result;
22731 char *kwnames[] = {
22732 NULL
22733 };
22734
22735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
22736 {
22737 PyThreadState* __tstate = wxPyBeginAllowThreads();
22738 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
22739
22740 wxPyEndAllowThreads(__tstate);
22741 if (PyErr_Occurred()) SWIG_fail;
22742 }
22743 {
22744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22745 }
22746 return resultobj;
22747 fail:
22748 return NULL;
22749 }
22750
22751
22752 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22753 PyObject *resultobj;
22754 long result;
22755 char *kwnames[] = {
22756 NULL
22757 };
22758
22759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
22760 {
22761 PyThreadState* __tstate = wxPyBeginAllowThreads();
22762 result = (long)wxPyApp::GetMacAboutMenuItemId();
22763
22764 wxPyEndAllowThreads(__tstate);
22765 if (PyErr_Occurred()) SWIG_fail;
22766 }
22767 {
22768 resultobj = SWIG_From_long((long)(result));
22769 }
22770 return resultobj;
22771 fail:
22772 return NULL;
22773 }
22774
22775
22776 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22777 PyObject *resultobj;
22778 long result;
22779 char *kwnames[] = {
22780 NULL
22781 };
22782
22783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
22784 {
22785 PyThreadState* __tstate = wxPyBeginAllowThreads();
22786 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
22787
22788 wxPyEndAllowThreads(__tstate);
22789 if (PyErr_Occurred()) SWIG_fail;
22790 }
22791 {
22792 resultobj = SWIG_From_long((long)(result));
22793 }
22794 return resultobj;
22795 fail:
22796 return NULL;
22797 }
22798
22799
22800 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22801 PyObject *resultobj;
22802 long result;
22803 char *kwnames[] = {
22804 NULL
22805 };
22806
22807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
22808 {
22809 PyThreadState* __tstate = wxPyBeginAllowThreads();
22810 result = (long)wxPyApp::GetMacExitMenuItemId();
22811
22812 wxPyEndAllowThreads(__tstate);
22813 if (PyErr_Occurred()) SWIG_fail;
22814 }
22815 {
22816 resultobj = SWIG_From_long((long)(result));
22817 }
22818 return resultobj;
22819 fail:
22820 return NULL;
22821 }
22822
22823
22824 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
22825 PyObject *resultobj;
22826 wxString result;
22827 char *kwnames[] = {
22828 NULL
22829 };
22830
22831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
22832 {
22833 PyThreadState* __tstate = wxPyBeginAllowThreads();
22834 result = wxPyApp::GetMacHelpMenuTitleName();
22835
22836 wxPyEndAllowThreads(__tstate);
22837 if (PyErr_Occurred()) SWIG_fail;
22838 }
22839 {
22840 #if wxUSE_UNICODE
22841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22842 #else
22843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22844 #endif
22845 }
22846 return resultobj;
22847 fail:
22848 return NULL;
22849 }
22850
22851
22852 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22853 PyObject *resultobj;
22854 bool arg1 ;
22855 PyObject * obj0 = 0 ;
22856 char *kwnames[] = {
22857 (char *) "val", NULL
22858 };
22859
22860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
22861 {
22862 arg1 = (bool)(SWIG_As_bool(obj0));
22863 if (SWIG_arg_fail(1)) SWIG_fail;
22864 }
22865 {
22866 PyThreadState* __tstate = wxPyBeginAllowThreads();
22867 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
22868
22869 wxPyEndAllowThreads(__tstate);
22870 if (PyErr_Occurred()) SWIG_fail;
22871 }
22872 Py_INCREF(Py_None); resultobj = Py_None;
22873 return resultobj;
22874 fail:
22875 return NULL;
22876 }
22877
22878
22879 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22880 PyObject *resultobj;
22881 long arg1 ;
22882 PyObject * obj0 = 0 ;
22883 char *kwnames[] = {
22884 (char *) "val", NULL
22885 };
22886
22887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
22888 {
22889 arg1 = (long)(SWIG_As_long(obj0));
22890 if (SWIG_arg_fail(1)) SWIG_fail;
22891 }
22892 {
22893 PyThreadState* __tstate = wxPyBeginAllowThreads();
22894 wxPyApp::SetMacAboutMenuItemId(arg1);
22895
22896 wxPyEndAllowThreads(__tstate);
22897 if (PyErr_Occurred()) SWIG_fail;
22898 }
22899 Py_INCREF(Py_None); resultobj = Py_None;
22900 return resultobj;
22901 fail:
22902 return NULL;
22903 }
22904
22905
22906 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22907 PyObject *resultobj;
22908 long arg1 ;
22909 PyObject * obj0 = 0 ;
22910 char *kwnames[] = {
22911 (char *) "val", NULL
22912 };
22913
22914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
22915 {
22916 arg1 = (long)(SWIG_As_long(obj0));
22917 if (SWIG_arg_fail(1)) SWIG_fail;
22918 }
22919 {
22920 PyThreadState* __tstate = wxPyBeginAllowThreads();
22921 wxPyApp::SetMacPreferencesMenuItemId(arg1);
22922
22923 wxPyEndAllowThreads(__tstate);
22924 if (PyErr_Occurred()) SWIG_fail;
22925 }
22926 Py_INCREF(Py_None); resultobj = Py_None;
22927 return resultobj;
22928 fail:
22929 return NULL;
22930 }
22931
22932
22933 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
22934 PyObject *resultobj;
22935 long arg1 ;
22936 PyObject * obj0 = 0 ;
22937 char *kwnames[] = {
22938 (char *) "val", NULL
22939 };
22940
22941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
22942 {
22943 arg1 = (long)(SWIG_As_long(obj0));
22944 if (SWIG_arg_fail(1)) SWIG_fail;
22945 }
22946 {
22947 PyThreadState* __tstate = wxPyBeginAllowThreads();
22948 wxPyApp::SetMacExitMenuItemId(arg1);
22949
22950 wxPyEndAllowThreads(__tstate);
22951 if (PyErr_Occurred()) SWIG_fail;
22952 }
22953 Py_INCREF(Py_None); resultobj = Py_None;
22954 return resultobj;
22955 fail:
22956 return NULL;
22957 }
22958
22959
22960 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
22961 PyObject *resultobj;
22962 wxString *arg1 = 0 ;
22963 bool temp1 = false ;
22964 PyObject * obj0 = 0 ;
22965 char *kwnames[] = {
22966 (char *) "val", NULL
22967 };
22968
22969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
22970 {
22971 arg1 = wxString_in_helper(obj0);
22972 if (arg1 == NULL) SWIG_fail;
22973 temp1 = true;
22974 }
22975 {
22976 PyThreadState* __tstate = wxPyBeginAllowThreads();
22977 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
22978
22979 wxPyEndAllowThreads(__tstate);
22980 if (PyErr_Occurred()) SWIG_fail;
22981 }
22982 Py_INCREF(Py_None); resultobj = Py_None;
22983 {
22984 if (temp1)
22985 delete arg1;
22986 }
22987 return resultobj;
22988 fail:
22989 {
22990 if (temp1)
22991 delete arg1;
22992 }
22993 return NULL;
22994 }
22995
22996
22997 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
22998 PyObject *resultobj;
22999 wxPyApp *arg1 = (wxPyApp *) 0 ;
23000 PyObject * obj0 = 0 ;
23001 char *kwnames[] = {
23002 (char *) "self", NULL
23003 };
23004
23005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23007 if (SWIG_arg_fail(1)) SWIG_fail;
23008 {
23009 PyThreadState* __tstate = wxPyBeginAllowThreads();
23010 (arg1)->_BootstrapApp();
23011
23012 wxPyEndAllowThreads(__tstate);
23013 if (PyErr_Occurred()) SWIG_fail;
23014 }
23015 Py_INCREF(Py_None); resultobj = Py_None;
23016 return resultobj;
23017 fail:
23018 return NULL;
23019 }
23020
23021
23022 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23023 PyObject *resultobj;
23024 int result;
23025 char *kwnames[] = {
23026 NULL
23027 };
23028
23029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23030 {
23031 PyThreadState* __tstate = wxPyBeginAllowThreads();
23032 result = (int)PyApp_GetComCtl32Version();
23033
23034 wxPyEndAllowThreads(__tstate);
23035 if (PyErr_Occurred()) SWIG_fail;
23036 }
23037 {
23038 resultobj = SWIG_From_int((int)(result));
23039 }
23040 return resultobj;
23041 fail:
23042 return NULL;
23043 }
23044
23045
23046 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23047 PyObject *obj;
23048 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23049 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23050 Py_INCREF(obj);
23051 return Py_BuildValue((char *)"");
23052 }
23053 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23054 PyObject *resultobj;
23055 char *kwnames[] = {
23056 NULL
23057 };
23058
23059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23060 {
23061 PyThreadState* __tstate = wxPyBeginAllowThreads();
23062 wxExit();
23063
23064 wxPyEndAllowThreads(__tstate);
23065 if (PyErr_Occurred()) SWIG_fail;
23066 }
23067 Py_INCREF(Py_None); resultobj = Py_None;
23068 return resultobj;
23069 fail:
23070 return NULL;
23071 }
23072
23073
23074 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23075 PyObject *resultobj;
23076 bool result;
23077 char *kwnames[] = {
23078 NULL
23079 };
23080
23081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23082 {
23083 PyThreadState* __tstate = wxPyBeginAllowThreads();
23084 result = (bool)wxYield();
23085
23086 wxPyEndAllowThreads(__tstate);
23087 if (PyErr_Occurred()) SWIG_fail;
23088 }
23089 {
23090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23091 }
23092 return resultobj;
23093 fail:
23094 return NULL;
23095 }
23096
23097
23098 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23099 PyObject *resultobj;
23100 bool result;
23101 char *kwnames[] = {
23102 NULL
23103 };
23104
23105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23106 {
23107 PyThreadState* __tstate = wxPyBeginAllowThreads();
23108 result = (bool)wxYieldIfNeeded();
23109
23110 wxPyEndAllowThreads(__tstate);
23111 if (PyErr_Occurred()) SWIG_fail;
23112 }
23113 {
23114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23115 }
23116 return resultobj;
23117 fail:
23118 return NULL;
23119 }
23120
23121
23122 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23123 PyObject *resultobj;
23124 wxWindow *arg1 = (wxWindow *) NULL ;
23125 bool arg2 = (bool) false ;
23126 bool result;
23127 PyObject * obj0 = 0 ;
23128 PyObject * obj1 = 0 ;
23129 char *kwnames[] = {
23130 (char *) "win",(char *) "onlyIfNeeded", NULL
23131 };
23132
23133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23134 if (obj0) {
23135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23136 if (SWIG_arg_fail(1)) SWIG_fail;
23137 }
23138 if (obj1) {
23139 {
23140 arg2 = (bool)(SWIG_As_bool(obj1));
23141 if (SWIG_arg_fail(2)) SWIG_fail;
23142 }
23143 }
23144 {
23145 PyThreadState* __tstate = wxPyBeginAllowThreads();
23146 result = (bool)wxSafeYield(arg1,arg2);
23147
23148 wxPyEndAllowThreads(__tstate);
23149 if (PyErr_Occurred()) SWIG_fail;
23150 }
23151 {
23152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23153 }
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23161 PyObject *resultobj;
23162 char *kwnames[] = {
23163 NULL
23164 };
23165
23166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23167 {
23168 PyThreadState* __tstate = wxPyBeginAllowThreads();
23169 wxWakeUpIdle();
23170
23171 wxPyEndAllowThreads(__tstate);
23172 if (PyErr_Occurred()) SWIG_fail;
23173 }
23174 Py_INCREF(Py_None); resultobj = Py_None;
23175 return resultobj;
23176 fail:
23177 return NULL;
23178 }
23179
23180
23181 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23182 PyObject *resultobj;
23183 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23184 wxEvent *arg2 = 0 ;
23185 PyObject * obj0 = 0 ;
23186 PyObject * obj1 = 0 ;
23187 char *kwnames[] = {
23188 (char *) "dest",(char *) "event", NULL
23189 };
23190
23191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23193 if (SWIG_arg_fail(1)) SWIG_fail;
23194 {
23195 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23196 if (SWIG_arg_fail(2)) SWIG_fail;
23197 if (arg2 == NULL) {
23198 SWIG_null_ref("wxEvent");
23199 }
23200 if (SWIG_arg_fail(2)) SWIG_fail;
23201 }
23202 {
23203 PyThreadState* __tstate = wxPyBeginAllowThreads();
23204 wxPostEvent(arg1,*arg2);
23205
23206 wxPyEndAllowThreads(__tstate);
23207 if (PyErr_Occurred()) SWIG_fail;
23208 }
23209 Py_INCREF(Py_None); resultobj = Py_None;
23210 return resultobj;
23211 fail:
23212 return NULL;
23213 }
23214
23215
23216 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23217 PyObject *resultobj;
23218 char *kwnames[] = {
23219 NULL
23220 };
23221
23222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23223 {
23224 PyThreadState* __tstate = wxPyBeginAllowThreads();
23225 wxApp_CleanUp();
23226
23227 wxPyEndAllowThreads(__tstate);
23228 if (PyErr_Occurred()) SWIG_fail;
23229 }
23230 Py_INCREF(Py_None); resultobj = Py_None;
23231 return resultobj;
23232 fail:
23233 return NULL;
23234 }
23235
23236
23237 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23238 PyObject *resultobj;
23239 wxPyApp *result;
23240 char *kwnames[] = {
23241 NULL
23242 };
23243
23244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23245 {
23246 PyThreadState* __tstate = wxPyBeginAllowThreads();
23247 result = (wxPyApp *)wxPyGetApp();
23248
23249 wxPyEndAllowThreads(__tstate);
23250 if (PyErr_Occurred()) SWIG_fail;
23251 }
23252 {
23253 resultobj = wxPyMake_wxObject(result, 0);
23254 }
23255 return resultobj;
23256 fail:
23257 return NULL;
23258 }
23259
23260
23261 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23262 PyObject *resultobj;
23263 char *arg1 = (char *) 0 ;
23264 PyObject * obj0 = 0 ;
23265 char *kwnames[] = {
23266 (char *) "encoding", NULL
23267 };
23268
23269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23270 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23271 SWIG_arg_fail(1);SWIG_fail;
23272 }
23273 {
23274 PyThreadState* __tstate = wxPyBeginAllowThreads();
23275 wxSetDefaultPyEncoding((char const *)arg1);
23276
23277 wxPyEndAllowThreads(__tstate);
23278 if (PyErr_Occurred()) SWIG_fail;
23279 }
23280 Py_INCREF(Py_None); resultobj = Py_None;
23281 return resultobj;
23282 fail:
23283 return NULL;
23284 }
23285
23286
23287 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23288 PyObject *resultobj;
23289 char *result;
23290 char *kwnames[] = {
23291 NULL
23292 };
23293
23294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23295 {
23296 PyThreadState* __tstate = wxPyBeginAllowThreads();
23297 result = (char *)wxGetDefaultPyEncoding();
23298
23299 wxPyEndAllowThreads(__tstate);
23300 if (PyErr_Occurred()) SWIG_fail;
23301 }
23302 resultobj = SWIG_FromCharPtr(result);
23303 return resultobj;
23304 fail:
23305 return NULL;
23306 }
23307
23308
23309 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23310 PyObject *resultobj;
23311 wxEventLoop *result;
23312 char *kwnames[] = {
23313 NULL
23314 };
23315
23316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23317 {
23318 PyThreadState* __tstate = wxPyBeginAllowThreads();
23319 result = (wxEventLoop *)new wxEventLoop();
23320
23321 wxPyEndAllowThreads(__tstate);
23322 if (PyErr_Occurred()) SWIG_fail;
23323 }
23324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23332 PyObject *resultobj;
23333 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23334 PyObject * obj0 = 0 ;
23335 char *kwnames[] = {
23336 (char *) "self", NULL
23337 };
23338
23339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23341 if (SWIG_arg_fail(1)) SWIG_fail;
23342 {
23343 PyThreadState* __tstate = wxPyBeginAllowThreads();
23344 delete arg1;
23345
23346 wxPyEndAllowThreads(__tstate);
23347 if (PyErr_Occurred()) SWIG_fail;
23348 }
23349 Py_INCREF(Py_None); resultobj = Py_None;
23350 return resultobj;
23351 fail:
23352 return NULL;
23353 }
23354
23355
23356 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23357 PyObject *resultobj;
23358 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23359 int result;
23360 PyObject * obj0 = 0 ;
23361 char *kwnames[] = {
23362 (char *) "self", NULL
23363 };
23364
23365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23367 if (SWIG_arg_fail(1)) SWIG_fail;
23368 {
23369 PyThreadState* __tstate = wxPyBeginAllowThreads();
23370 result = (int)(arg1)->Run();
23371
23372 wxPyEndAllowThreads(__tstate);
23373 if (PyErr_Occurred()) SWIG_fail;
23374 }
23375 {
23376 resultobj = SWIG_From_int((int)(result));
23377 }
23378 return resultobj;
23379 fail:
23380 return NULL;
23381 }
23382
23383
23384 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23385 PyObject *resultobj;
23386 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23387 int arg2 = (int) 0 ;
23388 PyObject * obj0 = 0 ;
23389 PyObject * obj1 = 0 ;
23390 char *kwnames[] = {
23391 (char *) "self",(char *) "rc", NULL
23392 };
23393
23394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23396 if (SWIG_arg_fail(1)) SWIG_fail;
23397 if (obj1) {
23398 {
23399 arg2 = (int)(SWIG_As_int(obj1));
23400 if (SWIG_arg_fail(2)) SWIG_fail;
23401 }
23402 }
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 (arg1)->Exit(arg2);
23406
23407 wxPyEndAllowThreads(__tstate);
23408 if (PyErr_Occurred()) SWIG_fail;
23409 }
23410 Py_INCREF(Py_None); resultobj = Py_None;
23411 return resultobj;
23412 fail:
23413 return NULL;
23414 }
23415
23416
23417 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj;
23419 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23420 bool result;
23421 PyObject * obj0 = 0 ;
23422 char *kwnames[] = {
23423 (char *) "self", NULL
23424 };
23425
23426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23428 if (SWIG_arg_fail(1)) SWIG_fail;
23429 {
23430 PyThreadState* __tstate = wxPyBeginAllowThreads();
23431 result = (bool)((wxEventLoop const *)arg1)->Pending();
23432
23433 wxPyEndAllowThreads(__tstate);
23434 if (PyErr_Occurred()) SWIG_fail;
23435 }
23436 {
23437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23438 }
23439 return resultobj;
23440 fail:
23441 return NULL;
23442 }
23443
23444
23445 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23446 PyObject *resultobj;
23447 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23448 bool result;
23449 PyObject * obj0 = 0 ;
23450 char *kwnames[] = {
23451 (char *) "self", NULL
23452 };
23453
23454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23456 if (SWIG_arg_fail(1)) SWIG_fail;
23457 {
23458 PyThreadState* __tstate = wxPyBeginAllowThreads();
23459 result = (bool)(arg1)->Dispatch();
23460
23461 wxPyEndAllowThreads(__tstate);
23462 if (PyErr_Occurred()) SWIG_fail;
23463 }
23464 {
23465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23466 }
23467 return resultobj;
23468 fail:
23469 return NULL;
23470 }
23471
23472
23473 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23474 PyObject *resultobj;
23475 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23476 bool result;
23477 PyObject * obj0 = 0 ;
23478 char *kwnames[] = {
23479 (char *) "self", NULL
23480 };
23481
23482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23484 if (SWIG_arg_fail(1)) SWIG_fail;
23485 {
23486 PyThreadState* __tstate = wxPyBeginAllowThreads();
23487 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23488
23489 wxPyEndAllowThreads(__tstate);
23490 if (PyErr_Occurred()) SWIG_fail;
23491 }
23492 {
23493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23494 }
23495 return resultobj;
23496 fail:
23497 return NULL;
23498 }
23499
23500
23501 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23502 PyObject *resultobj;
23503 wxEventLoop *result;
23504 char *kwnames[] = {
23505 NULL
23506 };
23507
23508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23509 {
23510 PyThreadState* __tstate = wxPyBeginAllowThreads();
23511 result = (wxEventLoop *)wxEventLoop::GetActive();
23512
23513 wxPyEndAllowThreads(__tstate);
23514 if (PyErr_Occurred()) SWIG_fail;
23515 }
23516 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23517 return resultobj;
23518 fail:
23519 return NULL;
23520 }
23521
23522
23523 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23524 PyObject *resultobj;
23525 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23526 PyObject * obj0 = 0 ;
23527 char *kwnames[] = {
23528 (char *) "loop", NULL
23529 };
23530
23531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23533 if (SWIG_arg_fail(1)) SWIG_fail;
23534 {
23535 PyThreadState* __tstate = wxPyBeginAllowThreads();
23536 wxEventLoop::SetActive(arg1);
23537
23538 wxPyEndAllowThreads(__tstate);
23539 if (PyErr_Occurred()) SWIG_fail;
23540 }
23541 Py_INCREF(Py_None); resultobj = Py_None;
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23549 PyObject *obj;
23550 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23551 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23552 Py_INCREF(obj);
23553 return Py_BuildValue((char *)"");
23554 }
23555 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23556 PyObject *resultobj;
23557 int arg1 = (int) 0 ;
23558 int arg2 = (int) 0 ;
23559 int arg3 = (int) 0 ;
23560 wxAcceleratorEntry *result;
23561 PyObject * obj0 = 0 ;
23562 PyObject * obj1 = 0 ;
23563 PyObject * obj2 = 0 ;
23564 char *kwnames[] = {
23565 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23566 };
23567
23568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23569 if (obj0) {
23570 {
23571 arg1 = (int)(SWIG_As_int(obj0));
23572 if (SWIG_arg_fail(1)) SWIG_fail;
23573 }
23574 }
23575 if (obj1) {
23576 {
23577 arg2 = (int)(SWIG_As_int(obj1));
23578 if (SWIG_arg_fail(2)) SWIG_fail;
23579 }
23580 }
23581 if (obj2) {
23582 {
23583 arg3 = (int)(SWIG_As_int(obj2));
23584 if (SWIG_arg_fail(3)) SWIG_fail;
23585 }
23586 }
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23590
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23595 return resultobj;
23596 fail:
23597 return NULL;
23598 }
23599
23600
23601 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23602 PyObject *resultobj;
23603 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23604 PyObject * obj0 = 0 ;
23605 char *kwnames[] = {
23606 (char *) "self", NULL
23607 };
23608
23609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23611 if (SWIG_arg_fail(1)) SWIG_fail;
23612 {
23613 PyThreadState* __tstate = wxPyBeginAllowThreads();
23614 delete arg1;
23615
23616 wxPyEndAllowThreads(__tstate);
23617 if (PyErr_Occurred()) SWIG_fail;
23618 }
23619 Py_INCREF(Py_None); resultobj = Py_None;
23620 return resultobj;
23621 fail:
23622 return NULL;
23623 }
23624
23625
23626 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23627 PyObject *resultobj;
23628 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23629 int arg2 ;
23630 int arg3 ;
23631 int arg4 ;
23632 PyObject * obj0 = 0 ;
23633 PyObject * obj1 = 0 ;
23634 PyObject * obj2 = 0 ;
23635 PyObject * obj3 = 0 ;
23636 char *kwnames[] = {
23637 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23638 };
23639
23640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23642 if (SWIG_arg_fail(1)) SWIG_fail;
23643 {
23644 arg2 = (int)(SWIG_As_int(obj1));
23645 if (SWIG_arg_fail(2)) SWIG_fail;
23646 }
23647 {
23648 arg3 = (int)(SWIG_As_int(obj2));
23649 if (SWIG_arg_fail(3)) SWIG_fail;
23650 }
23651 {
23652 arg4 = (int)(SWIG_As_int(obj3));
23653 if (SWIG_arg_fail(4)) SWIG_fail;
23654 }
23655 {
23656 PyThreadState* __tstate = wxPyBeginAllowThreads();
23657 (arg1)->Set(arg2,arg3,arg4);
23658
23659 wxPyEndAllowThreads(__tstate);
23660 if (PyErr_Occurred()) SWIG_fail;
23661 }
23662 Py_INCREF(Py_None); resultobj = Py_None;
23663 return resultobj;
23664 fail:
23665 return NULL;
23666 }
23667
23668
23669 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
23670 PyObject *resultobj;
23671 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23672 int result;
23673 PyObject * obj0 = 0 ;
23674 char *kwnames[] = {
23675 (char *) "self", NULL
23676 };
23677
23678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
23679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23680 if (SWIG_arg_fail(1)) SWIG_fail;
23681 {
23682 PyThreadState* __tstate = wxPyBeginAllowThreads();
23683 result = (int)(arg1)->GetFlags();
23684
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 {
23689 resultobj = SWIG_From_int((int)(result));
23690 }
23691 return resultobj;
23692 fail:
23693 return NULL;
23694 }
23695
23696
23697 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
23698 PyObject *resultobj;
23699 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23700 int result;
23701 PyObject * obj0 = 0 ;
23702 char *kwnames[] = {
23703 (char *) "self", NULL
23704 };
23705
23706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
23707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23708 if (SWIG_arg_fail(1)) SWIG_fail;
23709 {
23710 PyThreadState* __tstate = wxPyBeginAllowThreads();
23711 result = (int)(arg1)->GetKeyCode();
23712
23713 wxPyEndAllowThreads(__tstate);
23714 if (PyErr_Occurred()) SWIG_fail;
23715 }
23716 {
23717 resultobj = SWIG_From_int((int)(result));
23718 }
23719 return resultobj;
23720 fail:
23721 return NULL;
23722 }
23723
23724
23725 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
23726 PyObject *resultobj;
23727 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23728 int result;
23729 PyObject * obj0 = 0 ;
23730 char *kwnames[] = {
23731 (char *) "self", NULL
23732 };
23733
23734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
23735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23736 if (SWIG_arg_fail(1)) SWIG_fail;
23737 {
23738 PyThreadState* __tstate = wxPyBeginAllowThreads();
23739 result = (int)(arg1)->GetCommand();
23740
23741 wxPyEndAllowThreads(__tstate);
23742 if (PyErr_Occurred()) SWIG_fail;
23743 }
23744 {
23745 resultobj = SWIG_From_int((int)(result));
23746 }
23747 return resultobj;
23748 fail:
23749 return NULL;
23750 }
23751
23752
23753 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
23754 PyObject *obj;
23755 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23756 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
23757 Py_INCREF(obj);
23758 return Py_BuildValue((char *)"");
23759 }
23760 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23761 PyObject *resultobj;
23762 int arg1 ;
23763 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
23764 wxAcceleratorTable *result;
23765 PyObject * obj0 = 0 ;
23766 char *kwnames[] = {
23767 (char *) "n", NULL
23768 };
23769
23770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
23771 {
23772 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
23773 if (arg2) arg1 = PyList_Size(obj0);
23774 else arg1 = 0;
23775 }
23776 {
23777 PyThreadState* __tstate = wxPyBeginAllowThreads();
23778 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
23779
23780 wxPyEndAllowThreads(__tstate);
23781 if (PyErr_Occurred()) SWIG_fail;
23782 }
23783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
23784 {
23785 delete [] arg2;
23786 }
23787 return resultobj;
23788 fail:
23789 {
23790 delete [] arg2;
23791 }
23792 return NULL;
23793 }
23794
23795
23796 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
23797 PyObject *resultobj;
23798 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23799 PyObject * obj0 = 0 ;
23800 char *kwnames[] = {
23801 (char *) "self", NULL
23802 };
23803
23804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
23805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23806 if (SWIG_arg_fail(1)) SWIG_fail;
23807 {
23808 PyThreadState* __tstate = wxPyBeginAllowThreads();
23809 delete arg1;
23810
23811 wxPyEndAllowThreads(__tstate);
23812 if (PyErr_Occurred()) SWIG_fail;
23813 }
23814 Py_INCREF(Py_None); resultobj = Py_None;
23815 return resultobj;
23816 fail:
23817 return NULL;
23818 }
23819
23820
23821 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
23822 PyObject *resultobj;
23823 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
23824 bool result;
23825 PyObject * obj0 = 0 ;
23826 char *kwnames[] = {
23827 (char *) "self", NULL
23828 };
23829
23830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
23831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
23832 if (SWIG_arg_fail(1)) SWIG_fail;
23833 {
23834 PyThreadState* __tstate = wxPyBeginAllowThreads();
23835 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
23836
23837 wxPyEndAllowThreads(__tstate);
23838 if (PyErr_Occurred()) SWIG_fail;
23839 }
23840 {
23841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23842 }
23843 return resultobj;
23844 fail:
23845 return NULL;
23846 }
23847
23848
23849 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
23850 PyObject *obj;
23851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23852 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
23853 Py_INCREF(obj);
23854 return Py_BuildValue((char *)"");
23855 }
23856 static int _wrap_NullAcceleratorTable_set(PyObject *) {
23857 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
23858 return 1;
23859 }
23860
23861
23862 static PyObject *_wrap_NullAcceleratorTable_get(void) {
23863 PyObject *pyobj;
23864
23865 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
23866 return pyobj;
23867 }
23868
23869
23870 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
23871 PyObject *resultobj;
23872 wxString *arg1 = 0 ;
23873 wxAcceleratorEntry *result;
23874 bool temp1 = false ;
23875 PyObject * obj0 = 0 ;
23876 char *kwnames[] = {
23877 (char *) "label", NULL
23878 };
23879
23880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
23881 {
23882 arg1 = wxString_in_helper(obj0);
23883 if (arg1 == NULL) SWIG_fail;
23884 temp1 = true;
23885 }
23886 {
23887 PyThreadState* __tstate = wxPyBeginAllowThreads();
23888 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
23889
23890 wxPyEndAllowThreads(__tstate);
23891 if (PyErr_Occurred()) SWIG_fail;
23892 }
23893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
23894 {
23895 if (temp1)
23896 delete arg1;
23897 }
23898 return resultobj;
23899 fail:
23900 {
23901 if (temp1)
23902 delete arg1;
23903 }
23904 return NULL;
23905 }
23906
23907
23908 static int _wrap_PanelNameStr_set(PyObject *) {
23909 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
23910 return 1;
23911 }
23912
23913
23914 static PyObject *_wrap_PanelNameStr_get(void) {
23915 PyObject *pyobj;
23916
23917 {
23918 #if wxUSE_UNICODE
23919 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
23920 #else
23921 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
23922 #endif
23923 }
23924 return pyobj;
23925 }
23926
23927
23928 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
23929 PyObject *resultobj;
23930 wxVisualAttributes *result;
23931 char *kwnames[] = {
23932 NULL
23933 };
23934
23935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
23936 {
23937 PyThreadState* __tstate = wxPyBeginAllowThreads();
23938 result = (wxVisualAttributes *)new_wxVisualAttributes();
23939
23940 wxPyEndAllowThreads(__tstate);
23941 if (PyErr_Occurred()) SWIG_fail;
23942 }
23943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
23944 return resultobj;
23945 fail:
23946 return NULL;
23947 }
23948
23949
23950 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
23951 PyObject *resultobj;
23952 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
23953 PyObject * obj0 = 0 ;
23954 char *kwnames[] = {
23955 (char *) "self", NULL
23956 };
23957
23958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
23959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
23960 if (SWIG_arg_fail(1)) SWIG_fail;
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 delete_wxVisualAttributes(arg1);
23964
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 Py_INCREF(Py_None); resultobj = Py_None;
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
23976 PyObject *resultobj;
23977 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
23978 wxFont *arg2 = (wxFont *) 0 ;
23979 PyObject * obj0 = 0 ;
23980 PyObject * obj1 = 0 ;
23981 char *kwnames[] = {
23982 (char *) "self",(char *) "font", NULL
23983 };
23984
23985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
23986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
23987 if (SWIG_arg_fail(1)) SWIG_fail;
23988 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
23989 if (SWIG_arg_fail(2)) SWIG_fail;
23990 if (arg1) (arg1)->font = *arg2;
23991
23992 Py_INCREF(Py_None); resultobj = Py_None;
23993 return resultobj;
23994 fail:
23995 return NULL;
23996 }
23997
23998
23999 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24000 PyObject *resultobj;
24001 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24002 wxFont *result;
24003 PyObject * obj0 = 0 ;
24004 char *kwnames[] = {
24005 (char *) "self", NULL
24006 };
24007
24008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24010 if (SWIG_arg_fail(1)) SWIG_fail;
24011 result = (wxFont *)& ((arg1)->font);
24012
24013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24014 return resultobj;
24015 fail:
24016 return NULL;
24017 }
24018
24019
24020 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24021 PyObject *resultobj;
24022 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24023 wxColour *arg2 = (wxColour *) 0 ;
24024 PyObject * obj0 = 0 ;
24025 PyObject * obj1 = 0 ;
24026 char *kwnames[] = {
24027 (char *) "self",(char *) "colFg", NULL
24028 };
24029
24030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24032 if (SWIG_arg_fail(1)) SWIG_fail;
24033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24034 if (SWIG_arg_fail(2)) SWIG_fail;
24035 if (arg1) (arg1)->colFg = *arg2;
24036
24037 Py_INCREF(Py_None); resultobj = Py_None;
24038 return resultobj;
24039 fail:
24040 return NULL;
24041 }
24042
24043
24044 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24045 PyObject *resultobj;
24046 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24047 wxColour *result;
24048 PyObject * obj0 = 0 ;
24049 char *kwnames[] = {
24050 (char *) "self", NULL
24051 };
24052
24053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24055 if (SWIG_arg_fail(1)) SWIG_fail;
24056 result = (wxColour *)& ((arg1)->colFg);
24057
24058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24059 return resultobj;
24060 fail:
24061 return NULL;
24062 }
24063
24064
24065 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24066 PyObject *resultobj;
24067 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24068 wxColour *arg2 = (wxColour *) 0 ;
24069 PyObject * obj0 = 0 ;
24070 PyObject * obj1 = 0 ;
24071 char *kwnames[] = {
24072 (char *) "self",(char *) "colBg", NULL
24073 };
24074
24075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24077 if (SWIG_arg_fail(1)) SWIG_fail;
24078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24079 if (SWIG_arg_fail(2)) SWIG_fail;
24080 if (arg1) (arg1)->colBg = *arg2;
24081
24082 Py_INCREF(Py_None); resultobj = Py_None;
24083 return resultobj;
24084 fail:
24085 return NULL;
24086 }
24087
24088
24089 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24090 PyObject *resultobj;
24091 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24092 wxColour *result;
24093 PyObject * obj0 = 0 ;
24094 char *kwnames[] = {
24095 (char *) "self", NULL
24096 };
24097
24098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24100 if (SWIG_arg_fail(1)) SWIG_fail;
24101 result = (wxColour *)& ((arg1)->colBg);
24102
24103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24104 return resultobj;
24105 fail:
24106 return NULL;
24107 }
24108
24109
24110 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24111 PyObject *obj;
24112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24113 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24114 Py_INCREF(obj);
24115 return Py_BuildValue((char *)"");
24116 }
24117 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24118 PyObject *resultobj;
24119 wxWindow *arg1 = (wxWindow *) 0 ;
24120 int arg2 = (int) (int)-1 ;
24121 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24122 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24123 wxSize const &arg4_defvalue = wxDefaultSize ;
24124 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24125 long arg5 = (long) 0 ;
24126 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24127 wxString *arg6 = (wxString *) &arg6_defvalue ;
24128 wxWindow *result;
24129 wxPoint temp3 ;
24130 wxSize temp4 ;
24131 bool temp6 = false ;
24132 PyObject * obj0 = 0 ;
24133 PyObject * obj1 = 0 ;
24134 PyObject * obj2 = 0 ;
24135 PyObject * obj3 = 0 ;
24136 PyObject * obj4 = 0 ;
24137 PyObject * obj5 = 0 ;
24138 char *kwnames[] = {
24139 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24140 };
24141
24142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24144 if (SWIG_arg_fail(1)) SWIG_fail;
24145 if (obj1) {
24146 {
24147 arg2 = (int const)(SWIG_As_int(obj1));
24148 if (SWIG_arg_fail(2)) SWIG_fail;
24149 }
24150 }
24151 if (obj2) {
24152 {
24153 arg3 = &temp3;
24154 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24155 }
24156 }
24157 if (obj3) {
24158 {
24159 arg4 = &temp4;
24160 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24161 }
24162 }
24163 if (obj4) {
24164 {
24165 arg5 = (long)(SWIG_As_long(obj4));
24166 if (SWIG_arg_fail(5)) SWIG_fail;
24167 }
24168 }
24169 if (obj5) {
24170 {
24171 arg6 = wxString_in_helper(obj5);
24172 if (arg6 == NULL) SWIG_fail;
24173 temp6 = true;
24174 }
24175 }
24176 {
24177 if (!wxPyCheckForApp()) SWIG_fail;
24178 PyThreadState* __tstate = wxPyBeginAllowThreads();
24179 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24180
24181 wxPyEndAllowThreads(__tstate);
24182 if (PyErr_Occurred()) SWIG_fail;
24183 }
24184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24185 {
24186 if (temp6)
24187 delete arg6;
24188 }
24189 return resultobj;
24190 fail:
24191 {
24192 if (temp6)
24193 delete arg6;
24194 }
24195 return NULL;
24196 }
24197
24198
24199 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24200 PyObject *resultobj;
24201 wxWindow *result;
24202 char *kwnames[] = {
24203 NULL
24204 };
24205
24206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24207 {
24208 if (!wxPyCheckForApp()) SWIG_fail;
24209 PyThreadState* __tstate = wxPyBeginAllowThreads();
24210 result = (wxWindow *)new wxWindow();
24211
24212 wxPyEndAllowThreads(__tstate);
24213 if (PyErr_Occurred()) SWIG_fail;
24214 }
24215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24216 return resultobj;
24217 fail:
24218 return NULL;
24219 }
24220
24221
24222 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24223 PyObject *resultobj;
24224 wxWindow *arg1 = (wxWindow *) 0 ;
24225 wxWindow *arg2 = (wxWindow *) 0 ;
24226 int arg3 = (int) (int)-1 ;
24227 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24228 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24229 wxSize const &arg5_defvalue = wxDefaultSize ;
24230 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24231 long arg6 = (long) 0 ;
24232 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24233 wxString *arg7 = (wxString *) &arg7_defvalue ;
24234 bool result;
24235 wxPoint temp4 ;
24236 wxSize temp5 ;
24237 bool temp7 = false ;
24238 PyObject * obj0 = 0 ;
24239 PyObject * obj1 = 0 ;
24240 PyObject * obj2 = 0 ;
24241 PyObject * obj3 = 0 ;
24242 PyObject * obj4 = 0 ;
24243 PyObject * obj5 = 0 ;
24244 PyObject * obj6 = 0 ;
24245 char *kwnames[] = {
24246 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24247 };
24248
24249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24251 if (SWIG_arg_fail(1)) SWIG_fail;
24252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24253 if (SWIG_arg_fail(2)) SWIG_fail;
24254 if (obj2) {
24255 {
24256 arg3 = (int const)(SWIG_As_int(obj2));
24257 if (SWIG_arg_fail(3)) SWIG_fail;
24258 }
24259 }
24260 if (obj3) {
24261 {
24262 arg4 = &temp4;
24263 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24264 }
24265 }
24266 if (obj4) {
24267 {
24268 arg5 = &temp5;
24269 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24270 }
24271 }
24272 if (obj5) {
24273 {
24274 arg6 = (long)(SWIG_As_long(obj5));
24275 if (SWIG_arg_fail(6)) SWIG_fail;
24276 }
24277 }
24278 if (obj6) {
24279 {
24280 arg7 = wxString_in_helper(obj6);
24281 if (arg7 == NULL) SWIG_fail;
24282 temp7 = true;
24283 }
24284 }
24285 {
24286 PyThreadState* __tstate = wxPyBeginAllowThreads();
24287 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24288
24289 wxPyEndAllowThreads(__tstate);
24290 if (PyErr_Occurred()) SWIG_fail;
24291 }
24292 {
24293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24294 }
24295 {
24296 if (temp7)
24297 delete arg7;
24298 }
24299 return resultobj;
24300 fail:
24301 {
24302 if (temp7)
24303 delete arg7;
24304 }
24305 return NULL;
24306 }
24307
24308
24309 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24310 PyObject *resultobj;
24311 wxWindow *arg1 = (wxWindow *) 0 ;
24312 bool arg2 = (bool) false ;
24313 bool result;
24314 PyObject * obj0 = 0 ;
24315 PyObject * obj1 = 0 ;
24316 char *kwnames[] = {
24317 (char *) "self",(char *) "force", NULL
24318 };
24319
24320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24322 if (SWIG_arg_fail(1)) SWIG_fail;
24323 if (obj1) {
24324 {
24325 arg2 = (bool)(SWIG_As_bool(obj1));
24326 if (SWIG_arg_fail(2)) SWIG_fail;
24327 }
24328 }
24329 {
24330 PyThreadState* __tstate = wxPyBeginAllowThreads();
24331 result = (bool)(arg1)->Close(arg2);
24332
24333 wxPyEndAllowThreads(__tstate);
24334 if (PyErr_Occurred()) SWIG_fail;
24335 }
24336 {
24337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24338 }
24339 return resultobj;
24340 fail:
24341 return NULL;
24342 }
24343
24344
24345 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24346 PyObject *resultobj;
24347 wxWindow *arg1 = (wxWindow *) 0 ;
24348 bool result;
24349 PyObject * obj0 = 0 ;
24350 char *kwnames[] = {
24351 (char *) "self", NULL
24352 };
24353
24354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24356 if (SWIG_arg_fail(1)) SWIG_fail;
24357 {
24358 PyThreadState* __tstate = wxPyBeginAllowThreads();
24359 result = (bool)(arg1)->Destroy();
24360
24361 wxPyEndAllowThreads(__tstate);
24362 if (PyErr_Occurred()) SWIG_fail;
24363 }
24364 {
24365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24366 }
24367 return resultobj;
24368 fail:
24369 return NULL;
24370 }
24371
24372
24373 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24374 PyObject *resultobj;
24375 wxWindow *arg1 = (wxWindow *) 0 ;
24376 bool result;
24377 PyObject * obj0 = 0 ;
24378 char *kwnames[] = {
24379 (char *) "self", NULL
24380 };
24381
24382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24384 if (SWIG_arg_fail(1)) SWIG_fail;
24385 {
24386 PyThreadState* __tstate = wxPyBeginAllowThreads();
24387 result = (bool)(arg1)->DestroyChildren();
24388
24389 wxPyEndAllowThreads(__tstate);
24390 if (PyErr_Occurred()) SWIG_fail;
24391 }
24392 {
24393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24394 }
24395 return resultobj;
24396 fail:
24397 return NULL;
24398 }
24399
24400
24401 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24402 PyObject *resultobj;
24403 wxWindow *arg1 = (wxWindow *) 0 ;
24404 bool result;
24405 PyObject * obj0 = 0 ;
24406 char *kwnames[] = {
24407 (char *) "self", NULL
24408 };
24409
24410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24412 if (SWIG_arg_fail(1)) SWIG_fail;
24413 {
24414 PyThreadState* __tstate = wxPyBeginAllowThreads();
24415 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24416
24417 wxPyEndAllowThreads(__tstate);
24418 if (PyErr_Occurred()) SWIG_fail;
24419 }
24420 {
24421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24422 }
24423 return resultobj;
24424 fail:
24425 return NULL;
24426 }
24427
24428
24429 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24430 PyObject *resultobj;
24431 wxWindow *arg1 = (wxWindow *) 0 ;
24432 wxString *arg2 = 0 ;
24433 bool temp2 = false ;
24434 PyObject * obj0 = 0 ;
24435 PyObject * obj1 = 0 ;
24436 char *kwnames[] = {
24437 (char *) "self",(char *) "title", NULL
24438 };
24439
24440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24442 if (SWIG_arg_fail(1)) SWIG_fail;
24443 {
24444 arg2 = wxString_in_helper(obj1);
24445 if (arg2 == NULL) SWIG_fail;
24446 temp2 = true;
24447 }
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 (arg1)->SetTitle((wxString const &)*arg2);
24451
24452 wxPyEndAllowThreads(__tstate);
24453 if (PyErr_Occurred()) SWIG_fail;
24454 }
24455 Py_INCREF(Py_None); resultobj = Py_None;
24456 {
24457 if (temp2)
24458 delete arg2;
24459 }
24460 return resultobj;
24461 fail:
24462 {
24463 if (temp2)
24464 delete arg2;
24465 }
24466 return NULL;
24467 }
24468
24469
24470 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24471 PyObject *resultobj;
24472 wxWindow *arg1 = (wxWindow *) 0 ;
24473 wxString result;
24474 PyObject * obj0 = 0 ;
24475 char *kwnames[] = {
24476 (char *) "self", NULL
24477 };
24478
24479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24481 if (SWIG_arg_fail(1)) SWIG_fail;
24482 {
24483 PyThreadState* __tstate = wxPyBeginAllowThreads();
24484 result = ((wxWindow const *)arg1)->GetTitle();
24485
24486 wxPyEndAllowThreads(__tstate);
24487 if (PyErr_Occurred()) SWIG_fail;
24488 }
24489 {
24490 #if wxUSE_UNICODE
24491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24492 #else
24493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24494 #endif
24495 }
24496 return resultobj;
24497 fail:
24498 return NULL;
24499 }
24500
24501
24502 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24503 PyObject *resultobj;
24504 wxWindow *arg1 = (wxWindow *) 0 ;
24505 wxString *arg2 = 0 ;
24506 bool temp2 = false ;
24507 PyObject * obj0 = 0 ;
24508 PyObject * obj1 = 0 ;
24509 char *kwnames[] = {
24510 (char *) "self",(char *) "label", NULL
24511 };
24512
24513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24515 if (SWIG_arg_fail(1)) SWIG_fail;
24516 {
24517 arg2 = wxString_in_helper(obj1);
24518 if (arg2 == NULL) SWIG_fail;
24519 temp2 = true;
24520 }
24521 {
24522 PyThreadState* __tstate = wxPyBeginAllowThreads();
24523 (arg1)->SetLabel((wxString const &)*arg2);
24524
24525 wxPyEndAllowThreads(__tstate);
24526 if (PyErr_Occurred()) SWIG_fail;
24527 }
24528 Py_INCREF(Py_None); resultobj = Py_None;
24529 {
24530 if (temp2)
24531 delete arg2;
24532 }
24533 return resultobj;
24534 fail:
24535 {
24536 if (temp2)
24537 delete arg2;
24538 }
24539 return NULL;
24540 }
24541
24542
24543 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24544 PyObject *resultobj;
24545 wxWindow *arg1 = (wxWindow *) 0 ;
24546 wxString result;
24547 PyObject * obj0 = 0 ;
24548 char *kwnames[] = {
24549 (char *) "self", NULL
24550 };
24551
24552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24554 if (SWIG_arg_fail(1)) SWIG_fail;
24555 {
24556 PyThreadState* __tstate = wxPyBeginAllowThreads();
24557 result = ((wxWindow const *)arg1)->GetLabel();
24558
24559 wxPyEndAllowThreads(__tstate);
24560 if (PyErr_Occurred()) SWIG_fail;
24561 }
24562 {
24563 #if wxUSE_UNICODE
24564 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24565 #else
24566 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24567 #endif
24568 }
24569 return resultobj;
24570 fail:
24571 return NULL;
24572 }
24573
24574
24575 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24576 PyObject *resultobj;
24577 wxWindow *arg1 = (wxWindow *) 0 ;
24578 wxString *arg2 = 0 ;
24579 bool temp2 = false ;
24580 PyObject * obj0 = 0 ;
24581 PyObject * obj1 = 0 ;
24582 char *kwnames[] = {
24583 (char *) "self",(char *) "name", NULL
24584 };
24585
24586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24588 if (SWIG_arg_fail(1)) SWIG_fail;
24589 {
24590 arg2 = wxString_in_helper(obj1);
24591 if (arg2 == NULL) SWIG_fail;
24592 temp2 = true;
24593 }
24594 {
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 (arg1)->SetName((wxString const &)*arg2);
24597
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 Py_INCREF(Py_None); resultobj = Py_None;
24602 {
24603 if (temp2)
24604 delete arg2;
24605 }
24606 return resultobj;
24607 fail:
24608 {
24609 if (temp2)
24610 delete arg2;
24611 }
24612 return NULL;
24613 }
24614
24615
24616 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24617 PyObject *resultobj;
24618 wxWindow *arg1 = (wxWindow *) 0 ;
24619 wxString result;
24620 PyObject * obj0 = 0 ;
24621 char *kwnames[] = {
24622 (char *) "self", NULL
24623 };
24624
24625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24627 if (SWIG_arg_fail(1)) SWIG_fail;
24628 {
24629 PyThreadState* __tstate = wxPyBeginAllowThreads();
24630 result = ((wxWindow const *)arg1)->GetName();
24631
24632 wxPyEndAllowThreads(__tstate);
24633 if (PyErr_Occurred()) SWIG_fail;
24634 }
24635 {
24636 #if wxUSE_UNICODE
24637 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24638 #else
24639 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24640 #endif
24641 }
24642 return resultobj;
24643 fail:
24644 return NULL;
24645 }
24646
24647
24648 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24649 PyObject *resultobj;
24650 wxWindow *arg1 = (wxWindow *) 0 ;
24651 wxWindowVariant arg2 ;
24652 PyObject * obj0 = 0 ;
24653 PyObject * obj1 = 0 ;
24654 char *kwnames[] = {
24655 (char *) "self",(char *) "variant", NULL
24656 };
24657
24658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
24659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24660 if (SWIG_arg_fail(1)) SWIG_fail;
24661 {
24662 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
24663 if (SWIG_arg_fail(2)) SWIG_fail;
24664 }
24665 {
24666 PyThreadState* __tstate = wxPyBeginAllowThreads();
24667 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
24668
24669 wxPyEndAllowThreads(__tstate);
24670 if (PyErr_Occurred()) SWIG_fail;
24671 }
24672 Py_INCREF(Py_None); resultobj = Py_None;
24673 return resultobj;
24674 fail:
24675 return NULL;
24676 }
24677
24678
24679 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24680 PyObject *resultobj;
24681 wxWindow *arg1 = (wxWindow *) 0 ;
24682 wxWindowVariant result;
24683 PyObject * obj0 = 0 ;
24684 char *kwnames[] = {
24685 (char *) "self", NULL
24686 };
24687
24688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
24689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24690 if (SWIG_arg_fail(1)) SWIG_fail;
24691 {
24692 PyThreadState* __tstate = wxPyBeginAllowThreads();
24693 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
24694
24695 wxPyEndAllowThreads(__tstate);
24696 if (PyErr_Occurred()) SWIG_fail;
24697 }
24698 resultobj = SWIG_From_int((result));
24699 return resultobj;
24700 fail:
24701 return NULL;
24702 }
24703
24704
24705 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
24706 PyObject *resultobj;
24707 wxWindow *arg1 = (wxWindow *) 0 ;
24708 int arg2 ;
24709 PyObject * obj0 = 0 ;
24710 PyObject * obj1 = 0 ;
24711 char *kwnames[] = {
24712 (char *) "self",(char *) "winid", NULL
24713 };
24714
24715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
24716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24717 if (SWIG_arg_fail(1)) SWIG_fail;
24718 {
24719 arg2 = (int)(SWIG_As_int(obj1));
24720 if (SWIG_arg_fail(2)) SWIG_fail;
24721 }
24722 {
24723 PyThreadState* __tstate = wxPyBeginAllowThreads();
24724 (arg1)->SetId(arg2);
24725
24726 wxPyEndAllowThreads(__tstate);
24727 if (PyErr_Occurred()) SWIG_fail;
24728 }
24729 Py_INCREF(Py_None); resultobj = Py_None;
24730 return resultobj;
24731 fail:
24732 return NULL;
24733 }
24734
24735
24736 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
24737 PyObject *resultobj;
24738 wxWindow *arg1 = (wxWindow *) 0 ;
24739 int result;
24740 PyObject * obj0 = 0 ;
24741 char *kwnames[] = {
24742 (char *) "self", NULL
24743 };
24744
24745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
24746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24747 if (SWIG_arg_fail(1)) SWIG_fail;
24748 {
24749 PyThreadState* __tstate = wxPyBeginAllowThreads();
24750 result = (int)((wxWindow const *)arg1)->GetId();
24751
24752 wxPyEndAllowThreads(__tstate);
24753 if (PyErr_Occurred()) SWIG_fail;
24754 }
24755 {
24756 resultobj = SWIG_From_int((int)(result));
24757 }
24758 return resultobj;
24759 fail:
24760 return NULL;
24761 }
24762
24763
24764 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24765 PyObject *resultobj;
24766 int result;
24767 char *kwnames[] = {
24768 NULL
24769 };
24770
24771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
24772 {
24773 PyThreadState* __tstate = wxPyBeginAllowThreads();
24774 result = (int)wxWindow::NewControlId();
24775
24776 wxPyEndAllowThreads(__tstate);
24777 if (PyErr_Occurred()) SWIG_fail;
24778 }
24779 {
24780 resultobj = SWIG_From_int((int)(result));
24781 }
24782 return resultobj;
24783 fail:
24784 return NULL;
24785 }
24786
24787
24788 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24789 PyObject *resultobj;
24790 int arg1 ;
24791 int result;
24792 PyObject * obj0 = 0 ;
24793 char *kwnames[] = {
24794 (char *) "winid", NULL
24795 };
24796
24797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
24798 {
24799 arg1 = (int)(SWIG_As_int(obj0));
24800 if (SWIG_arg_fail(1)) SWIG_fail;
24801 }
24802 {
24803 PyThreadState* __tstate = wxPyBeginAllowThreads();
24804 result = (int)wxWindow::NextControlId(arg1);
24805
24806 wxPyEndAllowThreads(__tstate);
24807 if (PyErr_Occurred()) SWIG_fail;
24808 }
24809 {
24810 resultobj = SWIG_From_int((int)(result));
24811 }
24812 return resultobj;
24813 fail:
24814 return NULL;
24815 }
24816
24817
24818 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
24819 PyObject *resultobj;
24820 int arg1 ;
24821 int result;
24822 PyObject * obj0 = 0 ;
24823 char *kwnames[] = {
24824 (char *) "winid", NULL
24825 };
24826
24827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
24828 {
24829 arg1 = (int)(SWIG_As_int(obj0));
24830 if (SWIG_arg_fail(1)) SWIG_fail;
24831 }
24832 {
24833 PyThreadState* __tstate = wxPyBeginAllowThreads();
24834 result = (int)wxWindow::PrevControlId(arg1);
24835
24836 wxPyEndAllowThreads(__tstate);
24837 if (PyErr_Occurred()) SWIG_fail;
24838 }
24839 {
24840 resultobj = SWIG_From_int((int)(result));
24841 }
24842 return resultobj;
24843 fail:
24844 return NULL;
24845 }
24846
24847
24848 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
24849 PyObject *resultobj;
24850 wxWindow *arg1 = (wxWindow *) 0 ;
24851 wxSize *arg2 = 0 ;
24852 wxSize temp2 ;
24853 PyObject * obj0 = 0 ;
24854 PyObject * obj1 = 0 ;
24855 char *kwnames[] = {
24856 (char *) "self",(char *) "size", NULL
24857 };
24858
24859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
24860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24861 if (SWIG_arg_fail(1)) SWIG_fail;
24862 {
24863 arg2 = &temp2;
24864 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
24865 }
24866 {
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 (arg1)->SetSize((wxSize const &)*arg2);
24869
24870 wxPyEndAllowThreads(__tstate);
24871 if (PyErr_Occurred()) SWIG_fail;
24872 }
24873 Py_INCREF(Py_None); resultobj = Py_None;
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
24881 PyObject *resultobj;
24882 wxWindow *arg1 = (wxWindow *) 0 ;
24883 int arg2 ;
24884 int arg3 ;
24885 int arg4 ;
24886 int arg5 ;
24887 int arg6 = (int) wxSIZE_AUTO ;
24888 PyObject * obj0 = 0 ;
24889 PyObject * obj1 = 0 ;
24890 PyObject * obj2 = 0 ;
24891 PyObject * obj3 = 0 ;
24892 PyObject * obj4 = 0 ;
24893 PyObject * obj5 = 0 ;
24894 char *kwnames[] = {
24895 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
24896 };
24897
24898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24900 if (SWIG_arg_fail(1)) SWIG_fail;
24901 {
24902 arg2 = (int)(SWIG_As_int(obj1));
24903 if (SWIG_arg_fail(2)) SWIG_fail;
24904 }
24905 {
24906 arg3 = (int)(SWIG_As_int(obj2));
24907 if (SWIG_arg_fail(3)) SWIG_fail;
24908 }
24909 {
24910 arg4 = (int)(SWIG_As_int(obj3));
24911 if (SWIG_arg_fail(4)) SWIG_fail;
24912 }
24913 {
24914 arg5 = (int)(SWIG_As_int(obj4));
24915 if (SWIG_arg_fail(5)) SWIG_fail;
24916 }
24917 if (obj5) {
24918 {
24919 arg6 = (int)(SWIG_As_int(obj5));
24920 if (SWIG_arg_fail(6)) SWIG_fail;
24921 }
24922 }
24923 {
24924 PyThreadState* __tstate = wxPyBeginAllowThreads();
24925 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
24926
24927 wxPyEndAllowThreads(__tstate);
24928 if (PyErr_Occurred()) SWIG_fail;
24929 }
24930 Py_INCREF(Py_None); resultobj = Py_None;
24931 return resultobj;
24932 fail:
24933 return NULL;
24934 }
24935
24936
24937 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
24938 PyObject *resultobj;
24939 wxWindow *arg1 = (wxWindow *) 0 ;
24940 wxRect *arg2 = 0 ;
24941 int arg3 = (int) wxSIZE_AUTO ;
24942 wxRect temp2 ;
24943 PyObject * obj0 = 0 ;
24944 PyObject * obj1 = 0 ;
24945 PyObject * obj2 = 0 ;
24946 char *kwnames[] = {
24947 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
24948 };
24949
24950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
24951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24952 if (SWIG_arg_fail(1)) SWIG_fail;
24953 {
24954 arg2 = &temp2;
24955 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24956 }
24957 if (obj2) {
24958 {
24959 arg3 = (int)(SWIG_As_int(obj2));
24960 if (SWIG_arg_fail(3)) SWIG_fail;
24961 }
24962 }
24963 {
24964 PyThreadState* __tstate = wxPyBeginAllowThreads();
24965 (arg1)->SetSize((wxRect const &)*arg2,arg3);
24966
24967 wxPyEndAllowThreads(__tstate);
24968 if (PyErr_Occurred()) SWIG_fail;
24969 }
24970 Py_INCREF(Py_None); resultobj = Py_None;
24971 return resultobj;
24972 fail:
24973 return NULL;
24974 }
24975
24976
24977 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
24978 PyObject *resultobj;
24979 wxWindow *arg1 = (wxWindow *) 0 ;
24980 int arg2 ;
24981 int arg3 ;
24982 PyObject * obj0 = 0 ;
24983 PyObject * obj1 = 0 ;
24984 PyObject * obj2 = 0 ;
24985 char *kwnames[] = {
24986 (char *) "self",(char *) "width",(char *) "height", NULL
24987 };
24988
24989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
24990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24991 if (SWIG_arg_fail(1)) SWIG_fail;
24992 {
24993 arg2 = (int)(SWIG_As_int(obj1));
24994 if (SWIG_arg_fail(2)) SWIG_fail;
24995 }
24996 {
24997 arg3 = (int)(SWIG_As_int(obj2));
24998 if (SWIG_arg_fail(3)) SWIG_fail;
24999 }
25000 {
25001 PyThreadState* __tstate = wxPyBeginAllowThreads();
25002 (arg1)->SetSize(arg2,arg3);
25003
25004 wxPyEndAllowThreads(__tstate);
25005 if (PyErr_Occurred()) SWIG_fail;
25006 }
25007 Py_INCREF(Py_None); resultobj = Py_None;
25008 return resultobj;
25009 fail:
25010 return NULL;
25011 }
25012
25013
25014 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25015 PyObject *resultobj;
25016 wxWindow *arg1 = (wxWindow *) 0 ;
25017 wxPoint *arg2 = 0 ;
25018 int arg3 = (int) wxSIZE_USE_EXISTING ;
25019 wxPoint temp2 ;
25020 PyObject * obj0 = 0 ;
25021 PyObject * obj1 = 0 ;
25022 PyObject * obj2 = 0 ;
25023 char *kwnames[] = {
25024 (char *) "self",(char *) "pt",(char *) "flags", NULL
25025 };
25026
25027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25029 if (SWIG_arg_fail(1)) SWIG_fail;
25030 {
25031 arg2 = &temp2;
25032 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25033 }
25034 if (obj2) {
25035 {
25036 arg3 = (int)(SWIG_As_int(obj2));
25037 if (SWIG_arg_fail(3)) SWIG_fail;
25038 }
25039 }
25040 {
25041 PyThreadState* __tstate = wxPyBeginAllowThreads();
25042 (arg1)->Move((wxPoint const &)*arg2,arg3);
25043
25044 wxPyEndAllowThreads(__tstate);
25045 if (PyErr_Occurred()) SWIG_fail;
25046 }
25047 Py_INCREF(Py_None); resultobj = Py_None;
25048 return resultobj;
25049 fail:
25050 return NULL;
25051 }
25052
25053
25054 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25055 PyObject *resultobj;
25056 wxWindow *arg1 = (wxWindow *) 0 ;
25057 int arg2 ;
25058 int arg3 ;
25059 int arg4 = (int) wxSIZE_USE_EXISTING ;
25060 PyObject * obj0 = 0 ;
25061 PyObject * obj1 = 0 ;
25062 PyObject * obj2 = 0 ;
25063 PyObject * obj3 = 0 ;
25064 char *kwnames[] = {
25065 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25066 };
25067
25068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25070 if (SWIG_arg_fail(1)) SWIG_fail;
25071 {
25072 arg2 = (int)(SWIG_As_int(obj1));
25073 if (SWIG_arg_fail(2)) SWIG_fail;
25074 }
25075 {
25076 arg3 = (int)(SWIG_As_int(obj2));
25077 if (SWIG_arg_fail(3)) SWIG_fail;
25078 }
25079 if (obj3) {
25080 {
25081 arg4 = (int)(SWIG_As_int(obj3));
25082 if (SWIG_arg_fail(4)) SWIG_fail;
25083 }
25084 }
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 (arg1)->Move(arg2,arg3,arg4);
25088
25089 wxPyEndAllowThreads(__tstate);
25090 if (PyErr_Occurred()) SWIG_fail;
25091 }
25092 Py_INCREF(Py_None); resultobj = Py_None;
25093 return resultobj;
25094 fail:
25095 return NULL;
25096 }
25097
25098
25099 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25100 PyObject *resultobj;
25101 wxWindow *arg1 = (wxWindow *) 0 ;
25102 wxSize const &arg2_defvalue = wxDefaultSize ;
25103 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25104 wxSize temp2 ;
25105 PyObject * obj0 = 0 ;
25106 PyObject * obj1 = 0 ;
25107 char *kwnames[] = {
25108 (char *) "self",(char *) "size", NULL
25109 };
25110
25111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25113 if (SWIG_arg_fail(1)) SWIG_fail;
25114 if (obj1) {
25115 {
25116 arg2 = &temp2;
25117 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25118 }
25119 }
25120 {
25121 PyThreadState* __tstate = wxPyBeginAllowThreads();
25122 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25123
25124 wxPyEndAllowThreads(__tstate);
25125 if (PyErr_Occurred()) SWIG_fail;
25126 }
25127 Py_INCREF(Py_None); resultobj = Py_None;
25128 return resultobj;
25129 fail:
25130 return NULL;
25131 }
25132
25133
25134 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25135 PyObject *resultobj;
25136 wxWindow *arg1 = (wxWindow *) 0 ;
25137 PyObject * obj0 = 0 ;
25138 char *kwnames[] = {
25139 (char *) "self", NULL
25140 };
25141
25142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25144 if (SWIG_arg_fail(1)) SWIG_fail;
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 (arg1)->Raise();
25148
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 Py_INCREF(Py_None); resultobj = Py_None;
25153 return resultobj;
25154 fail:
25155 return NULL;
25156 }
25157
25158
25159 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25160 PyObject *resultobj;
25161 wxWindow *arg1 = (wxWindow *) 0 ;
25162 PyObject * obj0 = 0 ;
25163 char *kwnames[] = {
25164 (char *) "self", NULL
25165 };
25166
25167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25169 if (SWIG_arg_fail(1)) SWIG_fail;
25170 {
25171 PyThreadState* __tstate = wxPyBeginAllowThreads();
25172 (arg1)->Lower();
25173
25174 wxPyEndAllowThreads(__tstate);
25175 if (PyErr_Occurred()) SWIG_fail;
25176 }
25177 Py_INCREF(Py_None); resultobj = Py_None;
25178 return resultobj;
25179 fail:
25180 return NULL;
25181 }
25182
25183
25184 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25185 PyObject *resultobj;
25186 wxWindow *arg1 = (wxWindow *) 0 ;
25187 wxSize *arg2 = 0 ;
25188 wxSize temp2 ;
25189 PyObject * obj0 = 0 ;
25190 PyObject * obj1 = 0 ;
25191 char *kwnames[] = {
25192 (char *) "self",(char *) "size", NULL
25193 };
25194
25195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25197 if (SWIG_arg_fail(1)) SWIG_fail;
25198 {
25199 arg2 = &temp2;
25200 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25201 }
25202 {
25203 PyThreadState* __tstate = wxPyBeginAllowThreads();
25204 (arg1)->SetClientSize((wxSize const &)*arg2);
25205
25206 wxPyEndAllowThreads(__tstate);
25207 if (PyErr_Occurred()) SWIG_fail;
25208 }
25209 Py_INCREF(Py_None); resultobj = Py_None;
25210 return resultobj;
25211 fail:
25212 return NULL;
25213 }
25214
25215
25216 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25217 PyObject *resultobj;
25218 wxWindow *arg1 = (wxWindow *) 0 ;
25219 int arg2 ;
25220 int arg3 ;
25221 PyObject * obj0 = 0 ;
25222 PyObject * obj1 = 0 ;
25223 PyObject * obj2 = 0 ;
25224 char *kwnames[] = {
25225 (char *) "self",(char *) "width",(char *) "height", NULL
25226 };
25227
25228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25230 if (SWIG_arg_fail(1)) SWIG_fail;
25231 {
25232 arg2 = (int)(SWIG_As_int(obj1));
25233 if (SWIG_arg_fail(2)) SWIG_fail;
25234 }
25235 {
25236 arg3 = (int)(SWIG_As_int(obj2));
25237 if (SWIG_arg_fail(3)) SWIG_fail;
25238 }
25239 {
25240 PyThreadState* __tstate = wxPyBeginAllowThreads();
25241 (arg1)->SetClientSize(arg2,arg3);
25242
25243 wxPyEndAllowThreads(__tstate);
25244 if (PyErr_Occurred()) SWIG_fail;
25245 }
25246 Py_INCREF(Py_None); resultobj = Py_None;
25247 return resultobj;
25248 fail:
25249 return NULL;
25250 }
25251
25252
25253 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25254 PyObject *resultobj;
25255 wxWindow *arg1 = (wxWindow *) 0 ;
25256 wxRect *arg2 = 0 ;
25257 wxRect temp2 ;
25258 PyObject * obj0 = 0 ;
25259 PyObject * obj1 = 0 ;
25260 char *kwnames[] = {
25261 (char *) "self",(char *) "rect", NULL
25262 };
25263
25264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25266 if (SWIG_arg_fail(1)) SWIG_fail;
25267 {
25268 arg2 = &temp2;
25269 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25270 }
25271 {
25272 PyThreadState* __tstate = wxPyBeginAllowThreads();
25273 (arg1)->SetClientSize((wxRect const &)*arg2);
25274
25275 wxPyEndAllowThreads(__tstate);
25276 if (PyErr_Occurred()) SWIG_fail;
25277 }
25278 Py_INCREF(Py_None); resultobj = Py_None;
25279 return resultobj;
25280 fail:
25281 return NULL;
25282 }
25283
25284
25285 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25286 PyObject *resultobj;
25287 wxWindow *arg1 = (wxWindow *) 0 ;
25288 wxPoint result;
25289 PyObject * obj0 = 0 ;
25290 char *kwnames[] = {
25291 (char *) "self", NULL
25292 };
25293
25294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25296 if (SWIG_arg_fail(1)) SWIG_fail;
25297 {
25298 PyThreadState* __tstate = wxPyBeginAllowThreads();
25299 result = (arg1)->GetPosition();
25300
25301 wxPyEndAllowThreads(__tstate);
25302 if (PyErr_Occurred()) SWIG_fail;
25303 }
25304 {
25305 wxPoint * resultptr;
25306 resultptr = new wxPoint((wxPoint &)(result));
25307 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25308 }
25309 return resultobj;
25310 fail:
25311 return NULL;
25312 }
25313
25314
25315 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25316 PyObject *resultobj;
25317 wxWindow *arg1 = (wxWindow *) 0 ;
25318 int *arg2 = (int *) 0 ;
25319 int *arg3 = (int *) 0 ;
25320 int temp2 ;
25321 int res2 = 0 ;
25322 int temp3 ;
25323 int res3 = 0 ;
25324 PyObject * obj0 = 0 ;
25325 char *kwnames[] = {
25326 (char *) "self", NULL
25327 };
25328
25329 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25330 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25333 if (SWIG_arg_fail(1)) SWIG_fail;
25334 {
25335 PyThreadState* __tstate = wxPyBeginAllowThreads();
25336 (arg1)->GetPosition(arg2,arg3);
25337
25338 wxPyEndAllowThreads(__tstate);
25339 if (PyErr_Occurred()) SWIG_fail;
25340 }
25341 Py_INCREF(Py_None); resultobj = Py_None;
25342 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25343 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25344 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25345 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25346 return resultobj;
25347 fail:
25348 return NULL;
25349 }
25350
25351
25352 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25353 PyObject *resultobj;
25354 wxWindow *arg1 = (wxWindow *) 0 ;
25355 wxSize result;
25356 PyObject * obj0 = 0 ;
25357 char *kwnames[] = {
25358 (char *) "self", NULL
25359 };
25360
25361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25363 if (SWIG_arg_fail(1)) SWIG_fail;
25364 {
25365 PyThreadState* __tstate = wxPyBeginAllowThreads();
25366 result = ((wxWindow const *)arg1)->GetSize();
25367
25368 wxPyEndAllowThreads(__tstate);
25369 if (PyErr_Occurred()) SWIG_fail;
25370 }
25371 {
25372 wxSize * resultptr;
25373 resultptr = new wxSize((wxSize &)(result));
25374 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25375 }
25376 return resultobj;
25377 fail:
25378 return NULL;
25379 }
25380
25381
25382 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25383 PyObject *resultobj;
25384 wxWindow *arg1 = (wxWindow *) 0 ;
25385 int *arg2 = (int *) 0 ;
25386 int *arg3 = (int *) 0 ;
25387 int temp2 ;
25388 int res2 = 0 ;
25389 int temp3 ;
25390 int res3 = 0 ;
25391 PyObject * obj0 = 0 ;
25392 char *kwnames[] = {
25393 (char *) "self", NULL
25394 };
25395
25396 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25397 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25400 if (SWIG_arg_fail(1)) SWIG_fail;
25401 {
25402 PyThreadState* __tstate = wxPyBeginAllowThreads();
25403 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25404
25405 wxPyEndAllowThreads(__tstate);
25406 if (PyErr_Occurred()) SWIG_fail;
25407 }
25408 Py_INCREF(Py_None); resultobj = Py_None;
25409 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25410 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25411 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25412 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25413 return resultobj;
25414 fail:
25415 return NULL;
25416 }
25417
25418
25419 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25420 PyObject *resultobj;
25421 wxWindow *arg1 = (wxWindow *) 0 ;
25422 wxRect result;
25423 PyObject * obj0 = 0 ;
25424 char *kwnames[] = {
25425 (char *) "self", NULL
25426 };
25427
25428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25430 if (SWIG_arg_fail(1)) SWIG_fail;
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 result = ((wxWindow const *)arg1)->GetRect();
25434
25435 wxPyEndAllowThreads(__tstate);
25436 if (PyErr_Occurred()) SWIG_fail;
25437 }
25438 {
25439 wxRect * resultptr;
25440 resultptr = new wxRect((wxRect &)(result));
25441 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25442 }
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25450 PyObject *resultobj;
25451 wxWindow *arg1 = (wxWindow *) 0 ;
25452 wxSize result;
25453 PyObject * obj0 = 0 ;
25454 char *kwnames[] = {
25455 (char *) "self", NULL
25456 };
25457
25458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25460 if (SWIG_arg_fail(1)) SWIG_fail;
25461 {
25462 PyThreadState* __tstate = wxPyBeginAllowThreads();
25463 result = ((wxWindow const *)arg1)->GetClientSize();
25464
25465 wxPyEndAllowThreads(__tstate);
25466 if (PyErr_Occurred()) SWIG_fail;
25467 }
25468 {
25469 wxSize * resultptr;
25470 resultptr = new wxSize((wxSize &)(result));
25471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25472 }
25473 return resultobj;
25474 fail:
25475 return NULL;
25476 }
25477
25478
25479 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25480 PyObject *resultobj;
25481 wxWindow *arg1 = (wxWindow *) 0 ;
25482 int *arg2 = (int *) 0 ;
25483 int *arg3 = (int *) 0 ;
25484 int temp2 ;
25485 int res2 = 0 ;
25486 int temp3 ;
25487 int res3 = 0 ;
25488 PyObject * obj0 = 0 ;
25489 char *kwnames[] = {
25490 (char *) "self", NULL
25491 };
25492
25493 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25494 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25497 if (SWIG_arg_fail(1)) SWIG_fail;
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25501
25502 wxPyEndAllowThreads(__tstate);
25503 if (PyErr_Occurred()) SWIG_fail;
25504 }
25505 Py_INCREF(Py_None); resultobj = Py_None;
25506 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25507 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25508 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25509 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25510 return resultobj;
25511 fail:
25512 return NULL;
25513 }
25514
25515
25516 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25517 PyObject *resultobj;
25518 wxWindow *arg1 = (wxWindow *) 0 ;
25519 wxPoint result;
25520 PyObject * obj0 = 0 ;
25521 char *kwnames[] = {
25522 (char *) "self", NULL
25523 };
25524
25525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25527 if (SWIG_arg_fail(1)) SWIG_fail;
25528 {
25529 PyThreadState* __tstate = wxPyBeginAllowThreads();
25530 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25531
25532 wxPyEndAllowThreads(__tstate);
25533 if (PyErr_Occurred()) SWIG_fail;
25534 }
25535 {
25536 wxPoint * resultptr;
25537 resultptr = new wxPoint((wxPoint &)(result));
25538 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25539 }
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25547 PyObject *resultobj;
25548 wxWindow *arg1 = (wxWindow *) 0 ;
25549 wxRect result;
25550 PyObject * obj0 = 0 ;
25551 char *kwnames[] = {
25552 (char *) "self", NULL
25553 };
25554
25555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25557 if (SWIG_arg_fail(1)) SWIG_fail;
25558 {
25559 PyThreadState* __tstate = wxPyBeginAllowThreads();
25560 result = ((wxWindow const *)arg1)->GetClientRect();
25561
25562 wxPyEndAllowThreads(__tstate);
25563 if (PyErr_Occurred()) SWIG_fail;
25564 }
25565 {
25566 wxRect * resultptr;
25567 resultptr = new wxRect((wxRect &)(result));
25568 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25569 }
25570 return resultobj;
25571 fail:
25572 return NULL;
25573 }
25574
25575
25576 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25577 PyObject *resultobj;
25578 wxWindow *arg1 = (wxWindow *) 0 ;
25579 wxSize result;
25580 PyObject * obj0 = 0 ;
25581 char *kwnames[] = {
25582 (char *) "self", NULL
25583 };
25584
25585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25587 if (SWIG_arg_fail(1)) SWIG_fail;
25588 {
25589 PyThreadState* __tstate = wxPyBeginAllowThreads();
25590 result = ((wxWindow const *)arg1)->GetBestSize();
25591
25592 wxPyEndAllowThreads(__tstate);
25593 if (PyErr_Occurred()) SWIG_fail;
25594 }
25595 {
25596 wxSize * resultptr;
25597 resultptr = new wxSize((wxSize &)(result));
25598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25599 }
25600 return resultobj;
25601 fail:
25602 return NULL;
25603 }
25604
25605
25606 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25607 PyObject *resultobj;
25608 wxWindow *arg1 = (wxWindow *) 0 ;
25609 int *arg2 = (int *) 0 ;
25610 int *arg3 = (int *) 0 ;
25611 int temp2 ;
25612 int res2 = 0 ;
25613 int temp3 ;
25614 int res3 = 0 ;
25615 PyObject * obj0 = 0 ;
25616 char *kwnames[] = {
25617 (char *) "self", NULL
25618 };
25619
25620 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25621 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25624 if (SWIG_arg_fail(1)) SWIG_fail;
25625 {
25626 PyThreadState* __tstate = wxPyBeginAllowThreads();
25627 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25628
25629 wxPyEndAllowThreads(__tstate);
25630 if (PyErr_Occurred()) SWIG_fail;
25631 }
25632 Py_INCREF(Py_None); resultobj = Py_None;
25633 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25634 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25635 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25636 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25644 PyObject *resultobj;
25645 wxWindow *arg1 = (wxWindow *) 0 ;
25646 PyObject * obj0 = 0 ;
25647 char *kwnames[] = {
25648 (char *) "self", NULL
25649 };
25650
25651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
25652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25653 if (SWIG_arg_fail(1)) SWIG_fail;
25654 {
25655 PyThreadState* __tstate = wxPyBeginAllowThreads();
25656 (arg1)->InvalidateBestSize();
25657
25658 wxPyEndAllowThreads(__tstate);
25659 if (PyErr_Occurred()) SWIG_fail;
25660 }
25661 Py_INCREF(Py_None); resultobj = Py_None;
25662 return resultobj;
25663 fail:
25664 return NULL;
25665 }
25666
25667
25668 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25669 PyObject *resultobj;
25670 wxWindow *arg1 = (wxWindow *) 0 ;
25671 wxSize result;
25672 PyObject * obj0 = 0 ;
25673 char *kwnames[] = {
25674 (char *) "self", NULL
25675 };
25676
25677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
25678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25679 if (SWIG_arg_fail(1)) SWIG_fail;
25680 {
25681 PyThreadState* __tstate = wxPyBeginAllowThreads();
25682 result = ((wxWindow const *)arg1)->GetBestFittingSize();
25683
25684 wxPyEndAllowThreads(__tstate);
25685 if (PyErr_Occurred()) SWIG_fail;
25686 }
25687 {
25688 wxSize * resultptr;
25689 resultptr = new wxSize((wxSize &)(result));
25690 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25691 }
25692 return resultobj;
25693 fail:
25694 return NULL;
25695 }
25696
25697
25698 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25699 PyObject *resultobj;
25700 wxWindow *arg1 = (wxWindow *) 0 ;
25701 wxSize result;
25702 PyObject * obj0 = 0 ;
25703 char *kwnames[] = {
25704 (char *) "self", NULL
25705 };
25706
25707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
25708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25709 if (SWIG_arg_fail(1)) SWIG_fail;
25710 {
25711 PyThreadState* __tstate = wxPyBeginAllowThreads();
25712 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
25713
25714 wxPyEndAllowThreads(__tstate);
25715 if (PyErr_Occurred()) SWIG_fail;
25716 }
25717 {
25718 wxSize * resultptr;
25719 resultptr = new wxSize((wxSize &)(result));
25720 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25721 }
25722 return resultobj;
25723 fail:
25724 return NULL;
25725 }
25726
25727
25728 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
25729 PyObject *resultobj;
25730 wxWindow *arg1 = (wxWindow *) 0 ;
25731 int arg2 = (int) wxBOTH ;
25732 PyObject * obj0 = 0 ;
25733 PyObject * obj1 = 0 ;
25734 char *kwnames[] = {
25735 (char *) "self",(char *) "direction", NULL
25736 };
25737
25738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",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 if (obj1) {
25742 {
25743 arg2 = (int)(SWIG_As_int(obj1));
25744 if (SWIG_arg_fail(2)) SWIG_fail;
25745 }
25746 }
25747 {
25748 PyThreadState* __tstate = wxPyBeginAllowThreads();
25749 (arg1)->Center(arg2);
25750
25751 wxPyEndAllowThreads(__tstate);
25752 if (PyErr_Occurred()) SWIG_fail;
25753 }
25754 Py_INCREF(Py_None); resultobj = Py_None;
25755 return resultobj;
25756 fail:
25757 return NULL;
25758 }
25759
25760
25761 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
25762 PyObject *resultobj;
25763 wxWindow *arg1 = (wxWindow *) 0 ;
25764 int arg2 = (int) wxBOTH ;
25765 PyObject * obj0 = 0 ;
25766 PyObject * obj1 = 0 ;
25767 char *kwnames[] = {
25768 (char *) "self",(char *) "dir", NULL
25769 };
25770
25771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
25772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25773 if (SWIG_arg_fail(1)) SWIG_fail;
25774 if (obj1) {
25775 {
25776 arg2 = (int)(SWIG_As_int(obj1));
25777 if (SWIG_arg_fail(2)) SWIG_fail;
25778 }
25779 }
25780 {
25781 PyThreadState* __tstate = wxPyBeginAllowThreads();
25782 (arg1)->CenterOnScreen(arg2);
25783
25784 wxPyEndAllowThreads(__tstate);
25785 if (PyErr_Occurred()) SWIG_fail;
25786 }
25787 Py_INCREF(Py_None); resultobj = Py_None;
25788 return resultobj;
25789 fail:
25790 return NULL;
25791 }
25792
25793
25794 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
25795 PyObject *resultobj;
25796 wxWindow *arg1 = (wxWindow *) 0 ;
25797 int arg2 = (int) wxBOTH ;
25798 PyObject * obj0 = 0 ;
25799 PyObject * obj1 = 0 ;
25800 char *kwnames[] = {
25801 (char *) "self",(char *) "dir", NULL
25802 };
25803
25804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
25805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25806 if (SWIG_arg_fail(1)) SWIG_fail;
25807 if (obj1) {
25808 {
25809 arg2 = (int)(SWIG_As_int(obj1));
25810 if (SWIG_arg_fail(2)) SWIG_fail;
25811 }
25812 }
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 (arg1)->CenterOnParent(arg2);
25816
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 Py_INCREF(Py_None); resultobj = Py_None;
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj;
25829 wxWindow *arg1 = (wxWindow *) 0 ;
25830 PyObject * obj0 = 0 ;
25831 char *kwnames[] = {
25832 (char *) "self", NULL
25833 };
25834
25835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
25836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25837 if (SWIG_arg_fail(1)) SWIG_fail;
25838 {
25839 PyThreadState* __tstate = wxPyBeginAllowThreads();
25840 (arg1)->Fit();
25841
25842 wxPyEndAllowThreads(__tstate);
25843 if (PyErr_Occurred()) SWIG_fail;
25844 }
25845 Py_INCREF(Py_None); resultobj = Py_None;
25846 return resultobj;
25847 fail:
25848 return NULL;
25849 }
25850
25851
25852 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
25853 PyObject *resultobj;
25854 wxWindow *arg1 = (wxWindow *) 0 ;
25855 PyObject * obj0 = 0 ;
25856 char *kwnames[] = {
25857 (char *) "self", NULL
25858 };
25859
25860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
25861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25862 if (SWIG_arg_fail(1)) SWIG_fail;
25863 {
25864 PyThreadState* __tstate = wxPyBeginAllowThreads();
25865 (arg1)->FitInside();
25866
25867 wxPyEndAllowThreads(__tstate);
25868 if (PyErr_Occurred()) SWIG_fail;
25869 }
25870 Py_INCREF(Py_None); resultobj = Py_None;
25871 return resultobj;
25872 fail:
25873 return NULL;
25874 }
25875
25876
25877 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
25878 PyObject *resultobj;
25879 wxWindow *arg1 = (wxWindow *) 0 ;
25880 int arg2 ;
25881 int arg3 ;
25882 int arg4 = (int) -1 ;
25883 int arg5 = (int) -1 ;
25884 int arg6 = (int) -1 ;
25885 int arg7 = (int) -1 ;
25886 PyObject * obj0 = 0 ;
25887 PyObject * obj1 = 0 ;
25888 PyObject * obj2 = 0 ;
25889 PyObject * obj3 = 0 ;
25890 PyObject * obj4 = 0 ;
25891 PyObject * obj5 = 0 ;
25892 PyObject * obj6 = 0 ;
25893 char *kwnames[] = {
25894 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
25895 };
25896
25897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25899 if (SWIG_arg_fail(1)) SWIG_fail;
25900 {
25901 arg2 = (int)(SWIG_As_int(obj1));
25902 if (SWIG_arg_fail(2)) SWIG_fail;
25903 }
25904 {
25905 arg3 = (int)(SWIG_As_int(obj2));
25906 if (SWIG_arg_fail(3)) SWIG_fail;
25907 }
25908 if (obj3) {
25909 {
25910 arg4 = (int)(SWIG_As_int(obj3));
25911 if (SWIG_arg_fail(4)) SWIG_fail;
25912 }
25913 }
25914 if (obj4) {
25915 {
25916 arg5 = (int)(SWIG_As_int(obj4));
25917 if (SWIG_arg_fail(5)) SWIG_fail;
25918 }
25919 }
25920 if (obj5) {
25921 {
25922 arg6 = (int)(SWIG_As_int(obj5));
25923 if (SWIG_arg_fail(6)) SWIG_fail;
25924 }
25925 }
25926 if (obj6) {
25927 {
25928 arg7 = (int)(SWIG_As_int(obj6));
25929 if (SWIG_arg_fail(7)) SWIG_fail;
25930 }
25931 }
25932 {
25933 PyThreadState* __tstate = wxPyBeginAllowThreads();
25934 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
25935
25936 wxPyEndAllowThreads(__tstate);
25937 if (PyErr_Occurred()) SWIG_fail;
25938 }
25939 Py_INCREF(Py_None); resultobj = Py_None;
25940 return resultobj;
25941 fail:
25942 return NULL;
25943 }
25944
25945
25946 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
25947 PyObject *resultobj;
25948 wxWindow *arg1 = (wxWindow *) 0 ;
25949 wxSize *arg2 = 0 ;
25950 wxSize const &arg3_defvalue = wxDefaultSize ;
25951 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
25952 wxSize const &arg4_defvalue = wxDefaultSize ;
25953 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25954 wxSize temp2 ;
25955 wxSize temp3 ;
25956 wxSize temp4 ;
25957 PyObject * obj0 = 0 ;
25958 PyObject * obj1 = 0 ;
25959 PyObject * obj2 = 0 ;
25960 PyObject * obj3 = 0 ;
25961 char *kwnames[] = {
25962 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
25963 };
25964
25965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25967 if (SWIG_arg_fail(1)) SWIG_fail;
25968 {
25969 arg2 = &temp2;
25970 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25971 }
25972 if (obj2) {
25973 {
25974 arg3 = &temp3;
25975 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
25976 }
25977 }
25978 if (obj3) {
25979 {
25980 arg4 = &temp4;
25981 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25982 }
25983 }
25984 {
25985 PyThreadState* __tstate = wxPyBeginAllowThreads();
25986 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
25987
25988 wxPyEndAllowThreads(__tstate);
25989 if (PyErr_Occurred()) SWIG_fail;
25990 }
25991 Py_INCREF(Py_None); resultobj = Py_None;
25992 return resultobj;
25993 fail:
25994 return NULL;
25995 }
25996
25997
25998 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
25999 PyObject *resultobj;
26000 wxWindow *arg1 = (wxWindow *) 0 ;
26001 int arg2 ;
26002 int arg3 ;
26003 int arg4 = (int) -1 ;
26004 int arg5 = (int) -1 ;
26005 PyObject * obj0 = 0 ;
26006 PyObject * obj1 = 0 ;
26007 PyObject * obj2 = 0 ;
26008 PyObject * obj3 = 0 ;
26009 PyObject * obj4 = 0 ;
26010 char *kwnames[] = {
26011 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26012 };
26013
26014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26016 if (SWIG_arg_fail(1)) SWIG_fail;
26017 {
26018 arg2 = (int)(SWIG_As_int(obj1));
26019 if (SWIG_arg_fail(2)) SWIG_fail;
26020 }
26021 {
26022 arg3 = (int)(SWIG_As_int(obj2));
26023 if (SWIG_arg_fail(3)) SWIG_fail;
26024 }
26025 if (obj3) {
26026 {
26027 arg4 = (int)(SWIG_As_int(obj3));
26028 if (SWIG_arg_fail(4)) SWIG_fail;
26029 }
26030 }
26031 if (obj4) {
26032 {
26033 arg5 = (int)(SWIG_As_int(obj4));
26034 if (SWIG_arg_fail(5)) SWIG_fail;
26035 }
26036 }
26037 {
26038 PyThreadState* __tstate = wxPyBeginAllowThreads();
26039 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26040
26041 wxPyEndAllowThreads(__tstate);
26042 if (PyErr_Occurred()) SWIG_fail;
26043 }
26044 Py_INCREF(Py_None); resultobj = Py_None;
26045 return resultobj;
26046 fail:
26047 return NULL;
26048 }
26049
26050
26051 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26052 PyObject *resultobj;
26053 wxWindow *arg1 = (wxWindow *) 0 ;
26054 wxSize *arg2 = 0 ;
26055 wxSize const &arg3_defvalue = wxDefaultSize ;
26056 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26057 wxSize temp2 ;
26058 wxSize temp3 ;
26059 PyObject * obj0 = 0 ;
26060 PyObject * obj1 = 0 ;
26061 PyObject * obj2 = 0 ;
26062 char *kwnames[] = {
26063 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26064 };
26065
26066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26068 if (SWIG_arg_fail(1)) SWIG_fail;
26069 {
26070 arg2 = &temp2;
26071 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26072 }
26073 if (obj2) {
26074 {
26075 arg3 = &temp3;
26076 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26077 }
26078 }
26079 {
26080 PyThreadState* __tstate = wxPyBeginAllowThreads();
26081 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26082
26083 wxPyEndAllowThreads(__tstate);
26084 if (PyErr_Occurred()) SWIG_fail;
26085 }
26086 Py_INCREF(Py_None); resultobj = Py_None;
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26094 PyObject *resultobj;
26095 wxWindow *arg1 = (wxWindow *) 0 ;
26096 wxSize result;
26097 PyObject * obj0 = 0 ;
26098 char *kwnames[] = {
26099 (char *) "self", NULL
26100 };
26101
26102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26104 if (SWIG_arg_fail(1)) SWIG_fail;
26105 {
26106 PyThreadState* __tstate = wxPyBeginAllowThreads();
26107 result = ((wxWindow const *)arg1)->GetMaxSize();
26108
26109 wxPyEndAllowThreads(__tstate);
26110 if (PyErr_Occurred()) SWIG_fail;
26111 }
26112 {
26113 wxSize * resultptr;
26114 resultptr = new wxSize((wxSize &)(result));
26115 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26116 }
26117 return resultobj;
26118 fail:
26119 return NULL;
26120 }
26121
26122
26123 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26124 PyObject *resultobj;
26125 wxWindow *arg1 = (wxWindow *) 0 ;
26126 wxSize result;
26127 PyObject * obj0 = 0 ;
26128 char *kwnames[] = {
26129 (char *) "self", NULL
26130 };
26131
26132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26134 if (SWIG_arg_fail(1)) SWIG_fail;
26135 {
26136 PyThreadState* __tstate = wxPyBeginAllowThreads();
26137 result = ((wxWindow const *)arg1)->GetMinSize();
26138
26139 wxPyEndAllowThreads(__tstate);
26140 if (PyErr_Occurred()) SWIG_fail;
26141 }
26142 {
26143 wxSize * resultptr;
26144 resultptr = new wxSize((wxSize &)(result));
26145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26146 }
26147 return resultobj;
26148 fail:
26149 return NULL;
26150 }
26151
26152
26153 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26154 PyObject *resultobj;
26155 wxWindow *arg1 = (wxWindow *) 0 ;
26156 wxSize *arg2 = 0 ;
26157 wxSize temp2 ;
26158 PyObject * obj0 = 0 ;
26159 PyObject * obj1 = 0 ;
26160 char *kwnames[] = {
26161 (char *) "self",(char *) "minSize", NULL
26162 };
26163
26164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26166 if (SWIG_arg_fail(1)) SWIG_fail;
26167 {
26168 arg2 = &temp2;
26169 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26170 }
26171 {
26172 PyThreadState* __tstate = wxPyBeginAllowThreads();
26173 (arg1)->SetMinSize((wxSize const &)*arg2);
26174
26175 wxPyEndAllowThreads(__tstate);
26176 if (PyErr_Occurred()) SWIG_fail;
26177 }
26178 Py_INCREF(Py_None); resultobj = Py_None;
26179 return resultobj;
26180 fail:
26181 return NULL;
26182 }
26183
26184
26185 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26186 PyObject *resultobj;
26187 wxWindow *arg1 = (wxWindow *) 0 ;
26188 wxSize *arg2 = 0 ;
26189 wxSize temp2 ;
26190 PyObject * obj0 = 0 ;
26191 PyObject * obj1 = 0 ;
26192 char *kwnames[] = {
26193 (char *) "self",(char *) "maxSize", NULL
26194 };
26195
26196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26198 if (SWIG_arg_fail(1)) SWIG_fail;
26199 {
26200 arg2 = &temp2;
26201 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26202 }
26203 {
26204 PyThreadState* __tstate = wxPyBeginAllowThreads();
26205 (arg1)->SetMaxSize((wxSize const &)*arg2);
26206
26207 wxPyEndAllowThreads(__tstate);
26208 if (PyErr_Occurred()) SWIG_fail;
26209 }
26210 Py_INCREF(Py_None); resultobj = Py_None;
26211 return resultobj;
26212 fail:
26213 return NULL;
26214 }
26215
26216
26217 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26218 PyObject *resultobj;
26219 wxWindow *arg1 = (wxWindow *) 0 ;
26220 int result;
26221 PyObject * obj0 = 0 ;
26222 char *kwnames[] = {
26223 (char *) "self", NULL
26224 };
26225
26226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26228 if (SWIG_arg_fail(1)) SWIG_fail;
26229 {
26230 PyThreadState* __tstate = wxPyBeginAllowThreads();
26231 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26232
26233 wxPyEndAllowThreads(__tstate);
26234 if (PyErr_Occurred()) SWIG_fail;
26235 }
26236 {
26237 resultobj = SWIG_From_int((int)(result));
26238 }
26239 return resultobj;
26240 fail:
26241 return NULL;
26242 }
26243
26244
26245 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26246 PyObject *resultobj;
26247 wxWindow *arg1 = (wxWindow *) 0 ;
26248 int result;
26249 PyObject * obj0 = 0 ;
26250 char *kwnames[] = {
26251 (char *) "self", NULL
26252 };
26253
26254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26256 if (SWIG_arg_fail(1)) SWIG_fail;
26257 {
26258 PyThreadState* __tstate = wxPyBeginAllowThreads();
26259 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26260
26261 wxPyEndAllowThreads(__tstate);
26262 if (PyErr_Occurred()) SWIG_fail;
26263 }
26264 {
26265 resultobj = SWIG_From_int((int)(result));
26266 }
26267 return resultobj;
26268 fail:
26269 return NULL;
26270 }
26271
26272
26273 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26274 PyObject *resultobj;
26275 wxWindow *arg1 = (wxWindow *) 0 ;
26276 int result;
26277 PyObject * obj0 = 0 ;
26278 char *kwnames[] = {
26279 (char *) "self", NULL
26280 };
26281
26282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26284 if (SWIG_arg_fail(1)) SWIG_fail;
26285 {
26286 PyThreadState* __tstate = wxPyBeginAllowThreads();
26287 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26288
26289 wxPyEndAllowThreads(__tstate);
26290 if (PyErr_Occurred()) SWIG_fail;
26291 }
26292 {
26293 resultobj = SWIG_From_int((int)(result));
26294 }
26295 return resultobj;
26296 fail:
26297 return NULL;
26298 }
26299
26300
26301 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26302 PyObject *resultobj;
26303 wxWindow *arg1 = (wxWindow *) 0 ;
26304 int result;
26305 PyObject * obj0 = 0 ;
26306 char *kwnames[] = {
26307 (char *) "self", NULL
26308 };
26309
26310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26312 if (SWIG_arg_fail(1)) SWIG_fail;
26313 {
26314 PyThreadState* __tstate = wxPyBeginAllowThreads();
26315 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26316
26317 wxPyEndAllowThreads(__tstate);
26318 if (PyErr_Occurred()) SWIG_fail;
26319 }
26320 {
26321 resultobj = SWIG_From_int((int)(result));
26322 }
26323 return resultobj;
26324 fail:
26325 return NULL;
26326 }
26327
26328
26329 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26330 PyObject *resultobj;
26331 wxWindow *arg1 = (wxWindow *) 0 ;
26332 wxSize *arg2 = 0 ;
26333 wxSize temp2 ;
26334 PyObject * obj0 = 0 ;
26335 PyObject * obj1 = 0 ;
26336 char *kwnames[] = {
26337 (char *) "self",(char *) "size", NULL
26338 };
26339
26340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26342 if (SWIG_arg_fail(1)) SWIG_fail;
26343 {
26344 arg2 = &temp2;
26345 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26346 }
26347 {
26348 PyThreadState* __tstate = wxPyBeginAllowThreads();
26349 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26350
26351 wxPyEndAllowThreads(__tstate);
26352 if (PyErr_Occurred()) SWIG_fail;
26353 }
26354 Py_INCREF(Py_None); resultobj = Py_None;
26355 return resultobj;
26356 fail:
26357 return NULL;
26358 }
26359
26360
26361 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26362 PyObject *resultobj;
26363 wxWindow *arg1 = (wxWindow *) 0 ;
26364 int arg2 ;
26365 int arg3 ;
26366 PyObject * obj0 = 0 ;
26367 PyObject * obj1 = 0 ;
26368 PyObject * obj2 = 0 ;
26369 char *kwnames[] = {
26370 (char *) "self",(char *) "w",(char *) "h", NULL
26371 };
26372
26373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26375 if (SWIG_arg_fail(1)) SWIG_fail;
26376 {
26377 arg2 = (int)(SWIG_As_int(obj1));
26378 if (SWIG_arg_fail(2)) SWIG_fail;
26379 }
26380 {
26381 arg3 = (int)(SWIG_As_int(obj2));
26382 if (SWIG_arg_fail(3)) SWIG_fail;
26383 }
26384 {
26385 PyThreadState* __tstate = wxPyBeginAllowThreads();
26386 (arg1)->SetVirtualSize(arg2,arg3);
26387
26388 wxPyEndAllowThreads(__tstate);
26389 if (PyErr_Occurred()) SWIG_fail;
26390 }
26391 Py_INCREF(Py_None); resultobj = Py_None;
26392 return resultobj;
26393 fail:
26394 return NULL;
26395 }
26396
26397
26398 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26399 PyObject *resultobj;
26400 wxWindow *arg1 = (wxWindow *) 0 ;
26401 wxSize result;
26402 PyObject * obj0 = 0 ;
26403 char *kwnames[] = {
26404 (char *) "self", NULL
26405 };
26406
26407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26409 if (SWIG_arg_fail(1)) SWIG_fail;
26410 {
26411 PyThreadState* __tstate = wxPyBeginAllowThreads();
26412 result = ((wxWindow const *)arg1)->GetVirtualSize();
26413
26414 wxPyEndAllowThreads(__tstate);
26415 if (PyErr_Occurred()) SWIG_fail;
26416 }
26417 {
26418 wxSize * resultptr;
26419 resultptr = new wxSize((wxSize &)(result));
26420 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26421 }
26422 return resultobj;
26423 fail:
26424 return NULL;
26425 }
26426
26427
26428 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26429 PyObject *resultobj;
26430 wxWindow *arg1 = (wxWindow *) 0 ;
26431 int *arg2 = (int *) 0 ;
26432 int *arg3 = (int *) 0 ;
26433 int temp2 ;
26434 int res2 = 0 ;
26435 int temp3 ;
26436 int res3 = 0 ;
26437 PyObject * obj0 = 0 ;
26438 char *kwnames[] = {
26439 (char *) "self", NULL
26440 };
26441
26442 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26443 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26446 if (SWIG_arg_fail(1)) SWIG_fail;
26447 {
26448 PyThreadState* __tstate = wxPyBeginAllowThreads();
26449 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26450
26451 wxPyEndAllowThreads(__tstate);
26452 if (PyErr_Occurred()) SWIG_fail;
26453 }
26454 Py_INCREF(Py_None); resultobj = Py_None;
26455 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26456 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26457 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26458 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26459 return resultobj;
26460 fail:
26461 return NULL;
26462 }
26463
26464
26465 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26466 PyObject *resultobj;
26467 wxWindow *arg1 = (wxWindow *) 0 ;
26468 wxSize result;
26469 PyObject * obj0 = 0 ;
26470 char *kwnames[] = {
26471 (char *) "self", NULL
26472 };
26473
26474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26476 if (SWIG_arg_fail(1)) SWIG_fail;
26477 {
26478 PyThreadState* __tstate = wxPyBeginAllowThreads();
26479 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26480
26481 wxPyEndAllowThreads(__tstate);
26482 if (PyErr_Occurred()) SWIG_fail;
26483 }
26484 {
26485 wxSize * resultptr;
26486 resultptr = new wxSize((wxSize &)(result));
26487 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26488 }
26489 return resultobj;
26490 fail:
26491 return NULL;
26492 }
26493
26494
26495 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26496 PyObject *resultobj;
26497 wxWindow *arg1 = (wxWindow *) 0 ;
26498 bool arg2 = (bool) true ;
26499 bool result;
26500 PyObject * obj0 = 0 ;
26501 PyObject * obj1 = 0 ;
26502 char *kwnames[] = {
26503 (char *) "self",(char *) "show", NULL
26504 };
26505
26506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26508 if (SWIG_arg_fail(1)) SWIG_fail;
26509 if (obj1) {
26510 {
26511 arg2 = (bool)(SWIG_As_bool(obj1));
26512 if (SWIG_arg_fail(2)) SWIG_fail;
26513 }
26514 }
26515 {
26516 PyThreadState* __tstate = wxPyBeginAllowThreads();
26517 result = (bool)(arg1)->Show(arg2);
26518
26519 wxPyEndAllowThreads(__tstate);
26520 if (PyErr_Occurred()) SWIG_fail;
26521 }
26522 {
26523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26524 }
26525 return resultobj;
26526 fail:
26527 return NULL;
26528 }
26529
26530
26531 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26532 PyObject *resultobj;
26533 wxWindow *arg1 = (wxWindow *) 0 ;
26534 bool result;
26535 PyObject * obj0 = 0 ;
26536 char *kwnames[] = {
26537 (char *) "self", NULL
26538 };
26539
26540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26542 if (SWIG_arg_fail(1)) SWIG_fail;
26543 {
26544 PyThreadState* __tstate = wxPyBeginAllowThreads();
26545 result = (bool)(arg1)->Hide();
26546
26547 wxPyEndAllowThreads(__tstate);
26548 if (PyErr_Occurred()) SWIG_fail;
26549 }
26550 {
26551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26552 }
26553 return resultobj;
26554 fail:
26555 return NULL;
26556 }
26557
26558
26559 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26560 PyObject *resultobj;
26561 wxWindow *arg1 = (wxWindow *) 0 ;
26562 bool arg2 = (bool) true ;
26563 bool result;
26564 PyObject * obj0 = 0 ;
26565 PyObject * obj1 = 0 ;
26566 char *kwnames[] = {
26567 (char *) "self",(char *) "enable", NULL
26568 };
26569
26570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26572 if (SWIG_arg_fail(1)) SWIG_fail;
26573 if (obj1) {
26574 {
26575 arg2 = (bool)(SWIG_As_bool(obj1));
26576 if (SWIG_arg_fail(2)) SWIG_fail;
26577 }
26578 }
26579 {
26580 PyThreadState* __tstate = wxPyBeginAllowThreads();
26581 result = (bool)(arg1)->Enable(arg2);
26582
26583 wxPyEndAllowThreads(__tstate);
26584 if (PyErr_Occurred()) SWIG_fail;
26585 }
26586 {
26587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26588 }
26589 return resultobj;
26590 fail:
26591 return NULL;
26592 }
26593
26594
26595 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26596 PyObject *resultobj;
26597 wxWindow *arg1 = (wxWindow *) 0 ;
26598 bool result;
26599 PyObject * obj0 = 0 ;
26600 char *kwnames[] = {
26601 (char *) "self", NULL
26602 };
26603
26604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26606 if (SWIG_arg_fail(1)) SWIG_fail;
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 result = (bool)(arg1)->Disable();
26610
26611 wxPyEndAllowThreads(__tstate);
26612 if (PyErr_Occurred()) SWIG_fail;
26613 }
26614 {
26615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26616 }
26617 return resultobj;
26618 fail:
26619 return NULL;
26620 }
26621
26622
26623 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26624 PyObject *resultobj;
26625 wxWindow *arg1 = (wxWindow *) 0 ;
26626 bool result;
26627 PyObject * obj0 = 0 ;
26628 char *kwnames[] = {
26629 (char *) "self", NULL
26630 };
26631
26632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26634 if (SWIG_arg_fail(1)) SWIG_fail;
26635 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 result = (bool)((wxWindow const *)arg1)->IsShown();
26638
26639 wxPyEndAllowThreads(__tstate);
26640 if (PyErr_Occurred()) SWIG_fail;
26641 }
26642 {
26643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26644 }
26645 return resultobj;
26646 fail:
26647 return NULL;
26648 }
26649
26650
26651 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26652 PyObject *resultobj;
26653 wxWindow *arg1 = (wxWindow *) 0 ;
26654 bool result;
26655 PyObject * obj0 = 0 ;
26656 char *kwnames[] = {
26657 (char *) "self", NULL
26658 };
26659
26660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
26661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26662 if (SWIG_arg_fail(1)) SWIG_fail;
26663 {
26664 PyThreadState* __tstate = wxPyBeginAllowThreads();
26665 result = (bool)((wxWindow const *)arg1)->IsEnabled();
26666
26667 wxPyEndAllowThreads(__tstate);
26668 if (PyErr_Occurred()) SWIG_fail;
26669 }
26670 {
26671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26672 }
26673 return resultobj;
26674 fail:
26675 return NULL;
26676 }
26677
26678
26679 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26680 PyObject *resultobj;
26681 wxWindow *arg1 = (wxWindow *) 0 ;
26682 long arg2 ;
26683 PyObject * obj0 = 0 ;
26684 PyObject * obj1 = 0 ;
26685 char *kwnames[] = {
26686 (char *) "self",(char *) "style", NULL
26687 };
26688
26689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
26690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26691 if (SWIG_arg_fail(1)) SWIG_fail;
26692 {
26693 arg2 = (long)(SWIG_As_long(obj1));
26694 if (SWIG_arg_fail(2)) SWIG_fail;
26695 }
26696 {
26697 PyThreadState* __tstate = wxPyBeginAllowThreads();
26698 (arg1)->SetWindowStyleFlag(arg2);
26699
26700 wxPyEndAllowThreads(__tstate);
26701 if (PyErr_Occurred()) SWIG_fail;
26702 }
26703 Py_INCREF(Py_None); resultobj = Py_None;
26704 return resultobj;
26705 fail:
26706 return NULL;
26707 }
26708
26709
26710 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26711 PyObject *resultobj;
26712 wxWindow *arg1 = (wxWindow *) 0 ;
26713 long result;
26714 PyObject * obj0 = 0 ;
26715 char *kwnames[] = {
26716 (char *) "self", NULL
26717 };
26718
26719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
26720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26721 if (SWIG_arg_fail(1)) SWIG_fail;
26722 {
26723 PyThreadState* __tstate = wxPyBeginAllowThreads();
26724 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
26725
26726 wxPyEndAllowThreads(__tstate);
26727 if (PyErr_Occurred()) SWIG_fail;
26728 }
26729 {
26730 resultobj = SWIG_From_long((long)(result));
26731 }
26732 return resultobj;
26733 fail:
26734 return NULL;
26735 }
26736
26737
26738 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26739 PyObject *resultobj;
26740 wxWindow *arg1 = (wxWindow *) 0 ;
26741 int arg2 ;
26742 bool result;
26743 PyObject * obj0 = 0 ;
26744 PyObject * obj1 = 0 ;
26745 char *kwnames[] = {
26746 (char *) "self",(char *) "flag", NULL
26747 };
26748
26749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
26750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26751 if (SWIG_arg_fail(1)) SWIG_fail;
26752 {
26753 arg2 = (int)(SWIG_As_int(obj1));
26754 if (SWIG_arg_fail(2)) SWIG_fail;
26755 }
26756 {
26757 PyThreadState* __tstate = wxPyBeginAllowThreads();
26758 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
26759
26760 wxPyEndAllowThreads(__tstate);
26761 if (PyErr_Occurred()) SWIG_fail;
26762 }
26763 {
26764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26765 }
26766 return resultobj;
26767 fail:
26768 return NULL;
26769 }
26770
26771
26772 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
26773 PyObject *resultobj;
26774 wxWindow *arg1 = (wxWindow *) 0 ;
26775 bool result;
26776 PyObject * obj0 = 0 ;
26777 char *kwnames[] = {
26778 (char *) "self", NULL
26779 };
26780
26781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
26782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26783 if (SWIG_arg_fail(1)) SWIG_fail;
26784 {
26785 PyThreadState* __tstate = wxPyBeginAllowThreads();
26786 result = (bool)((wxWindow const *)arg1)->IsRetained();
26787
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 {
26792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26793 }
26794 return resultobj;
26795 fail:
26796 return NULL;
26797 }
26798
26799
26800 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26801 PyObject *resultobj;
26802 wxWindow *arg1 = (wxWindow *) 0 ;
26803 long arg2 ;
26804 PyObject * obj0 = 0 ;
26805 PyObject * obj1 = 0 ;
26806 char *kwnames[] = {
26807 (char *) "self",(char *) "exStyle", NULL
26808 };
26809
26810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
26811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26812 if (SWIG_arg_fail(1)) SWIG_fail;
26813 {
26814 arg2 = (long)(SWIG_As_long(obj1));
26815 if (SWIG_arg_fail(2)) SWIG_fail;
26816 }
26817 {
26818 PyThreadState* __tstate = wxPyBeginAllowThreads();
26819 (arg1)->SetExtraStyle(arg2);
26820
26821 wxPyEndAllowThreads(__tstate);
26822 if (PyErr_Occurred()) SWIG_fail;
26823 }
26824 Py_INCREF(Py_None); resultobj = Py_None;
26825 return resultobj;
26826 fail:
26827 return NULL;
26828 }
26829
26830
26831 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
26832 PyObject *resultobj;
26833 wxWindow *arg1 = (wxWindow *) 0 ;
26834 long result;
26835 PyObject * obj0 = 0 ;
26836 char *kwnames[] = {
26837 (char *) "self", NULL
26838 };
26839
26840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
26841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26842 if (SWIG_arg_fail(1)) SWIG_fail;
26843 {
26844 PyThreadState* __tstate = wxPyBeginAllowThreads();
26845 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
26846
26847 wxPyEndAllowThreads(__tstate);
26848 if (PyErr_Occurred()) SWIG_fail;
26849 }
26850 {
26851 resultobj = SWIG_From_long((long)(result));
26852 }
26853 return resultobj;
26854 fail:
26855 return NULL;
26856 }
26857
26858
26859 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
26860 PyObject *resultobj;
26861 wxWindow *arg1 = (wxWindow *) 0 ;
26862 bool arg2 = (bool) true ;
26863 PyObject * obj0 = 0 ;
26864 PyObject * obj1 = 0 ;
26865 char *kwnames[] = {
26866 (char *) "self",(char *) "modal", NULL
26867 };
26868
26869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
26870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26871 if (SWIG_arg_fail(1)) SWIG_fail;
26872 if (obj1) {
26873 {
26874 arg2 = (bool)(SWIG_As_bool(obj1));
26875 if (SWIG_arg_fail(2)) SWIG_fail;
26876 }
26877 }
26878 {
26879 PyThreadState* __tstate = wxPyBeginAllowThreads();
26880 (arg1)->MakeModal(arg2);
26881
26882 wxPyEndAllowThreads(__tstate);
26883 if (PyErr_Occurred()) SWIG_fail;
26884 }
26885 Py_INCREF(Py_None); resultobj = Py_None;
26886 return resultobj;
26887 fail:
26888 return NULL;
26889 }
26890
26891
26892 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26893 PyObject *resultobj;
26894 wxWindow *arg1 = (wxWindow *) 0 ;
26895 bool arg2 ;
26896 PyObject * obj0 = 0 ;
26897 PyObject * obj1 = 0 ;
26898 char *kwnames[] = {
26899 (char *) "self",(char *) "enableTheme", NULL
26900 };
26901
26902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
26903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26904 if (SWIG_arg_fail(1)) SWIG_fail;
26905 {
26906 arg2 = (bool)(SWIG_As_bool(obj1));
26907 if (SWIG_arg_fail(2)) SWIG_fail;
26908 }
26909 {
26910 PyThreadState* __tstate = wxPyBeginAllowThreads();
26911 (arg1)->SetThemeEnabled(arg2);
26912
26913 wxPyEndAllowThreads(__tstate);
26914 if (PyErr_Occurred()) SWIG_fail;
26915 }
26916 Py_INCREF(Py_None); resultobj = Py_None;
26917 return resultobj;
26918 fail:
26919 return NULL;
26920 }
26921
26922
26923 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26924 PyObject *resultobj;
26925 wxWindow *arg1 = (wxWindow *) 0 ;
26926 bool result;
26927 PyObject * obj0 = 0 ;
26928 char *kwnames[] = {
26929 (char *) "self", NULL
26930 };
26931
26932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
26933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26934 if (SWIG_arg_fail(1)) SWIG_fail;
26935 {
26936 PyThreadState* __tstate = wxPyBeginAllowThreads();
26937 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
26938
26939 wxPyEndAllowThreads(__tstate);
26940 if (PyErr_Occurred()) SWIG_fail;
26941 }
26942 {
26943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26944 }
26945 return resultobj;
26946 fail:
26947 return NULL;
26948 }
26949
26950
26951 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
26952 PyObject *resultobj;
26953 wxWindow *arg1 = (wxWindow *) 0 ;
26954 PyObject * obj0 = 0 ;
26955 char *kwnames[] = {
26956 (char *) "self", NULL
26957 };
26958
26959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
26960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26961 if (SWIG_arg_fail(1)) SWIG_fail;
26962 {
26963 PyThreadState* __tstate = wxPyBeginAllowThreads();
26964 (arg1)->SetFocus();
26965
26966 wxPyEndAllowThreads(__tstate);
26967 if (PyErr_Occurred()) SWIG_fail;
26968 }
26969 Py_INCREF(Py_None); resultobj = Py_None;
26970 return resultobj;
26971 fail:
26972 return NULL;
26973 }
26974
26975
26976 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
26977 PyObject *resultobj;
26978 wxWindow *arg1 = (wxWindow *) 0 ;
26979 PyObject * obj0 = 0 ;
26980 char *kwnames[] = {
26981 (char *) "self", NULL
26982 };
26983
26984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
26985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26986 if (SWIG_arg_fail(1)) SWIG_fail;
26987 {
26988 PyThreadState* __tstate = wxPyBeginAllowThreads();
26989 (arg1)->SetFocusFromKbd();
26990
26991 wxPyEndAllowThreads(__tstate);
26992 if (PyErr_Occurred()) SWIG_fail;
26993 }
26994 Py_INCREF(Py_None); resultobj = Py_None;
26995 return resultobj;
26996 fail:
26997 return NULL;
26998 }
26999
27000
27001 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27002 PyObject *resultobj;
27003 wxWindow *result;
27004 char *kwnames[] = {
27005 NULL
27006 };
27007
27008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27009 {
27010 if (!wxPyCheckForApp()) SWIG_fail;
27011 PyThreadState* __tstate = wxPyBeginAllowThreads();
27012 result = (wxWindow *)wxWindow::FindFocus();
27013
27014 wxPyEndAllowThreads(__tstate);
27015 if (PyErr_Occurred()) SWIG_fail;
27016 }
27017 {
27018 resultobj = wxPyMake_wxObject(result, 0);
27019 }
27020 return resultobj;
27021 fail:
27022 return NULL;
27023 }
27024
27025
27026 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27027 PyObject *resultobj;
27028 wxWindow *arg1 = (wxWindow *) 0 ;
27029 bool result;
27030 PyObject * obj0 = 0 ;
27031 char *kwnames[] = {
27032 (char *) "self", NULL
27033 };
27034
27035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27037 if (SWIG_arg_fail(1)) SWIG_fail;
27038 {
27039 PyThreadState* __tstate = wxPyBeginAllowThreads();
27040 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27041
27042 wxPyEndAllowThreads(__tstate);
27043 if (PyErr_Occurred()) SWIG_fail;
27044 }
27045 {
27046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27047 }
27048 return resultobj;
27049 fail:
27050 return NULL;
27051 }
27052
27053
27054 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27055 PyObject *resultobj;
27056 wxWindow *arg1 = (wxWindow *) 0 ;
27057 bool result;
27058 PyObject * obj0 = 0 ;
27059 char *kwnames[] = {
27060 (char *) "self", NULL
27061 };
27062
27063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27065 if (SWIG_arg_fail(1)) SWIG_fail;
27066 {
27067 PyThreadState* __tstate = wxPyBeginAllowThreads();
27068 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27069
27070 wxPyEndAllowThreads(__tstate);
27071 if (PyErr_Occurred()) SWIG_fail;
27072 }
27073 {
27074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27075 }
27076 return resultobj;
27077 fail:
27078 return NULL;
27079 }
27080
27081
27082 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27083 PyObject *resultobj;
27084 wxWindow *arg1 = (wxWindow *) 0 ;
27085 wxWindow *result;
27086 PyObject * obj0 = 0 ;
27087 char *kwnames[] = {
27088 (char *) "self", NULL
27089 };
27090
27091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27093 if (SWIG_arg_fail(1)) SWIG_fail;
27094 {
27095 PyThreadState* __tstate = wxPyBeginAllowThreads();
27096 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27097
27098 wxPyEndAllowThreads(__tstate);
27099 if (PyErr_Occurred()) SWIG_fail;
27100 }
27101 {
27102 resultobj = wxPyMake_wxObject(result, 0);
27103 }
27104 return resultobj;
27105 fail:
27106 return NULL;
27107 }
27108
27109
27110 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27111 PyObject *resultobj;
27112 wxWindow *arg1 = (wxWindow *) 0 ;
27113 wxWindow *arg2 = (wxWindow *) 0 ;
27114 wxWindow *result;
27115 PyObject * obj0 = 0 ;
27116 PyObject * obj1 = 0 ;
27117 char *kwnames[] = {
27118 (char *) "self",(char *) "child", NULL
27119 };
27120
27121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27123 if (SWIG_arg_fail(1)) SWIG_fail;
27124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27125 if (SWIG_arg_fail(2)) SWIG_fail;
27126 {
27127 PyThreadState* __tstate = wxPyBeginAllowThreads();
27128 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27129
27130 wxPyEndAllowThreads(__tstate);
27131 if (PyErr_Occurred()) SWIG_fail;
27132 }
27133 {
27134 resultobj = wxPyMake_wxObject(result, 0);
27135 }
27136 return resultobj;
27137 fail:
27138 return NULL;
27139 }
27140
27141
27142 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27143 PyObject *resultobj;
27144 wxWindow *arg1 = (wxWindow *) 0 ;
27145 wxWindow *arg2 = (wxWindow *) 0 ;
27146 PyObject * obj0 = 0 ;
27147 PyObject * obj1 = 0 ;
27148 char *kwnames[] = {
27149 (char *) "self",(char *) "win", NULL
27150 };
27151
27152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27154 if (SWIG_arg_fail(1)) SWIG_fail;
27155 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27156 if (SWIG_arg_fail(2)) SWIG_fail;
27157 {
27158 PyThreadState* __tstate = wxPyBeginAllowThreads();
27159 (arg1)->SetTmpDefaultItem(arg2);
27160
27161 wxPyEndAllowThreads(__tstate);
27162 if (PyErr_Occurred()) SWIG_fail;
27163 }
27164 Py_INCREF(Py_None); resultobj = Py_None;
27165 return resultobj;
27166 fail:
27167 return NULL;
27168 }
27169
27170
27171 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27172 PyObject *resultobj;
27173 wxWindow *arg1 = (wxWindow *) 0 ;
27174 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27175 bool result;
27176 PyObject * obj0 = 0 ;
27177 PyObject * obj1 = 0 ;
27178 char *kwnames[] = {
27179 (char *) "self",(char *) "flags", NULL
27180 };
27181
27182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
27183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27184 if (SWIG_arg_fail(1)) SWIG_fail;
27185 if (obj1) {
27186 {
27187 arg2 = (int)(SWIG_As_int(obj1));
27188 if (SWIG_arg_fail(2)) SWIG_fail;
27189 }
27190 }
27191 {
27192 PyThreadState* __tstate = wxPyBeginAllowThreads();
27193 result = (bool)(arg1)->Navigate(arg2);
27194
27195 wxPyEndAllowThreads(__tstate);
27196 if (PyErr_Occurred()) SWIG_fail;
27197 }
27198 {
27199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27200 }
27201 return resultobj;
27202 fail:
27203 return NULL;
27204 }
27205
27206
27207 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27208 PyObject *resultobj;
27209 wxWindow *arg1 = (wxWindow *) 0 ;
27210 wxWindow *arg2 = (wxWindow *) 0 ;
27211 PyObject * obj0 = 0 ;
27212 PyObject * obj1 = 0 ;
27213 char *kwnames[] = {
27214 (char *) "self",(char *) "win", NULL
27215 };
27216
27217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27219 if (SWIG_arg_fail(1)) SWIG_fail;
27220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27221 if (SWIG_arg_fail(2)) SWIG_fail;
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 (arg1)->MoveAfterInTabOrder(arg2);
27225
27226 wxPyEndAllowThreads(__tstate);
27227 if (PyErr_Occurred()) SWIG_fail;
27228 }
27229 Py_INCREF(Py_None); resultobj = Py_None;
27230 return resultobj;
27231 fail:
27232 return NULL;
27233 }
27234
27235
27236 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27237 PyObject *resultobj;
27238 wxWindow *arg1 = (wxWindow *) 0 ;
27239 wxWindow *arg2 = (wxWindow *) 0 ;
27240 PyObject * obj0 = 0 ;
27241 PyObject * obj1 = 0 ;
27242 char *kwnames[] = {
27243 (char *) "self",(char *) "win", NULL
27244 };
27245
27246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27248 if (SWIG_arg_fail(1)) SWIG_fail;
27249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27250 if (SWIG_arg_fail(2)) SWIG_fail;
27251 {
27252 PyThreadState* __tstate = wxPyBeginAllowThreads();
27253 (arg1)->MoveBeforeInTabOrder(arg2);
27254
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 Py_INCREF(Py_None); resultobj = Py_None;
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27266 PyObject *resultobj;
27267 wxWindow *arg1 = (wxWindow *) 0 ;
27268 PyObject *result;
27269 PyObject * obj0 = 0 ;
27270 char *kwnames[] = {
27271 (char *) "self", NULL
27272 };
27273
27274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27276 if (SWIG_arg_fail(1)) SWIG_fail;
27277 {
27278 PyThreadState* __tstate = wxPyBeginAllowThreads();
27279 result = (PyObject *)wxWindow_GetChildren(arg1);
27280
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 resultobj = result;
27285 return resultobj;
27286 fail:
27287 return NULL;
27288 }
27289
27290
27291 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27292 PyObject *resultobj;
27293 wxWindow *arg1 = (wxWindow *) 0 ;
27294 wxWindow *result;
27295 PyObject * obj0 = 0 ;
27296 char *kwnames[] = {
27297 (char *) "self", NULL
27298 };
27299
27300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27302 if (SWIG_arg_fail(1)) SWIG_fail;
27303 {
27304 PyThreadState* __tstate = wxPyBeginAllowThreads();
27305 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27306
27307 wxPyEndAllowThreads(__tstate);
27308 if (PyErr_Occurred()) SWIG_fail;
27309 }
27310 {
27311 resultobj = wxPyMake_wxObject(result, 0);
27312 }
27313 return resultobj;
27314 fail:
27315 return NULL;
27316 }
27317
27318
27319 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27320 PyObject *resultobj;
27321 wxWindow *arg1 = (wxWindow *) 0 ;
27322 wxWindow *result;
27323 PyObject * obj0 = 0 ;
27324 char *kwnames[] = {
27325 (char *) "self", NULL
27326 };
27327
27328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27330 if (SWIG_arg_fail(1)) SWIG_fail;
27331 {
27332 PyThreadState* __tstate = wxPyBeginAllowThreads();
27333 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27334
27335 wxPyEndAllowThreads(__tstate);
27336 if (PyErr_Occurred()) SWIG_fail;
27337 }
27338 {
27339 resultobj = wxPyMake_wxObject(result, 0);
27340 }
27341 return resultobj;
27342 fail:
27343 return NULL;
27344 }
27345
27346
27347 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27348 PyObject *resultobj;
27349 wxWindow *arg1 = (wxWindow *) 0 ;
27350 bool result;
27351 PyObject * obj0 = 0 ;
27352 char *kwnames[] = {
27353 (char *) "self", NULL
27354 };
27355
27356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27358 if (SWIG_arg_fail(1)) SWIG_fail;
27359 {
27360 PyThreadState* __tstate = wxPyBeginAllowThreads();
27361 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27362
27363 wxPyEndAllowThreads(__tstate);
27364 if (PyErr_Occurred()) SWIG_fail;
27365 }
27366 {
27367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27368 }
27369 return resultobj;
27370 fail:
27371 return NULL;
27372 }
27373
27374
27375 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27376 PyObject *resultobj;
27377 wxWindow *arg1 = (wxWindow *) 0 ;
27378 wxWindow *arg2 = (wxWindow *) 0 ;
27379 bool result;
27380 PyObject * obj0 = 0 ;
27381 PyObject * obj1 = 0 ;
27382 char *kwnames[] = {
27383 (char *) "self",(char *) "newParent", NULL
27384 };
27385
27386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27388 if (SWIG_arg_fail(1)) SWIG_fail;
27389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27390 if (SWIG_arg_fail(2)) SWIG_fail;
27391 {
27392 PyThreadState* __tstate = wxPyBeginAllowThreads();
27393 result = (bool)(arg1)->Reparent(arg2);
27394
27395 wxPyEndAllowThreads(__tstate);
27396 if (PyErr_Occurred()) SWIG_fail;
27397 }
27398 {
27399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27400 }
27401 return resultobj;
27402 fail:
27403 return NULL;
27404 }
27405
27406
27407 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27408 PyObject *resultobj;
27409 wxWindow *arg1 = (wxWindow *) 0 ;
27410 wxWindow *arg2 = (wxWindow *) 0 ;
27411 PyObject * obj0 = 0 ;
27412 PyObject * obj1 = 0 ;
27413 char *kwnames[] = {
27414 (char *) "self",(char *) "child", NULL
27415 };
27416
27417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27419 if (SWIG_arg_fail(1)) SWIG_fail;
27420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27421 if (SWIG_arg_fail(2)) SWIG_fail;
27422 {
27423 PyThreadState* __tstate = wxPyBeginAllowThreads();
27424 (arg1)->AddChild(arg2);
27425
27426 wxPyEndAllowThreads(__tstate);
27427 if (PyErr_Occurred()) SWIG_fail;
27428 }
27429 Py_INCREF(Py_None); resultobj = Py_None;
27430 return resultobj;
27431 fail:
27432 return NULL;
27433 }
27434
27435
27436 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27437 PyObject *resultobj;
27438 wxWindow *arg1 = (wxWindow *) 0 ;
27439 wxWindow *arg2 = (wxWindow *) 0 ;
27440 PyObject * obj0 = 0 ;
27441 PyObject * obj1 = 0 ;
27442 char *kwnames[] = {
27443 (char *) "self",(char *) "child", NULL
27444 };
27445
27446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27448 if (SWIG_arg_fail(1)) SWIG_fail;
27449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27450 if (SWIG_arg_fail(2)) SWIG_fail;
27451 {
27452 PyThreadState* __tstate = wxPyBeginAllowThreads();
27453 (arg1)->RemoveChild(arg2);
27454
27455 wxPyEndAllowThreads(__tstate);
27456 if (PyErr_Occurred()) SWIG_fail;
27457 }
27458 Py_INCREF(Py_None); resultobj = Py_None;
27459 return resultobj;
27460 fail:
27461 return NULL;
27462 }
27463
27464
27465 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27466 PyObject *resultobj;
27467 wxWindow *arg1 = (wxWindow *) 0 ;
27468 long arg2 ;
27469 wxWindow *result;
27470 PyObject * obj0 = 0 ;
27471 PyObject * obj1 = 0 ;
27472 char *kwnames[] = {
27473 (char *) "self",(char *) "winid", NULL
27474 };
27475
27476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27478 if (SWIG_arg_fail(1)) SWIG_fail;
27479 {
27480 arg2 = (long)(SWIG_As_long(obj1));
27481 if (SWIG_arg_fail(2)) SWIG_fail;
27482 }
27483 {
27484 PyThreadState* __tstate = wxPyBeginAllowThreads();
27485 result = (wxWindow *)(arg1)->FindWindow(arg2);
27486
27487 wxPyEndAllowThreads(__tstate);
27488 if (PyErr_Occurred()) SWIG_fail;
27489 }
27490 {
27491 resultobj = wxPyMake_wxObject(result, 0);
27492 }
27493 return resultobj;
27494 fail:
27495 return NULL;
27496 }
27497
27498
27499 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27500 PyObject *resultobj;
27501 wxWindow *arg1 = (wxWindow *) 0 ;
27502 wxString *arg2 = 0 ;
27503 wxWindow *result;
27504 bool temp2 = false ;
27505 PyObject * obj0 = 0 ;
27506 PyObject * obj1 = 0 ;
27507 char *kwnames[] = {
27508 (char *) "self",(char *) "name", NULL
27509 };
27510
27511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
27516 if (arg2 == NULL) SWIG_fail;
27517 temp2 = true;
27518 }
27519 {
27520 PyThreadState* __tstate = wxPyBeginAllowThreads();
27521 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27522
27523 wxPyEndAllowThreads(__tstate);
27524 if (PyErr_Occurred()) SWIG_fail;
27525 }
27526 {
27527 resultobj = wxPyMake_wxObject(result, 0);
27528 }
27529 {
27530 if (temp2)
27531 delete arg2;
27532 }
27533 return resultobj;
27534 fail:
27535 {
27536 if (temp2)
27537 delete arg2;
27538 }
27539 return NULL;
27540 }
27541
27542
27543 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27544 PyObject *resultobj;
27545 wxWindow *arg1 = (wxWindow *) 0 ;
27546 wxEvtHandler *result;
27547 PyObject * obj0 = 0 ;
27548 char *kwnames[] = {
27549 (char *) "self", NULL
27550 };
27551
27552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27554 if (SWIG_arg_fail(1)) SWIG_fail;
27555 {
27556 PyThreadState* __tstate = wxPyBeginAllowThreads();
27557 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27558
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 {
27563 resultobj = wxPyMake_wxObject(result, 0);
27564 }
27565 return resultobj;
27566 fail:
27567 return NULL;
27568 }
27569
27570
27571 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27572 PyObject *resultobj;
27573 wxWindow *arg1 = (wxWindow *) 0 ;
27574 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27575 PyObject * obj0 = 0 ;
27576 PyObject * obj1 = 0 ;
27577 char *kwnames[] = {
27578 (char *) "self",(char *) "handler", NULL
27579 };
27580
27581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27583 if (SWIG_arg_fail(1)) SWIG_fail;
27584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27585 if (SWIG_arg_fail(2)) SWIG_fail;
27586 {
27587 PyThreadState* __tstate = wxPyBeginAllowThreads();
27588 (arg1)->SetEventHandler(arg2);
27589
27590 wxPyEndAllowThreads(__tstate);
27591 if (PyErr_Occurred()) SWIG_fail;
27592 }
27593 Py_INCREF(Py_None); resultobj = Py_None;
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27601 PyObject *resultobj;
27602 wxWindow *arg1 = (wxWindow *) 0 ;
27603 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27604 PyObject * obj0 = 0 ;
27605 PyObject * obj1 = 0 ;
27606 char *kwnames[] = {
27607 (char *) "self",(char *) "handler", NULL
27608 };
27609
27610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27612 if (SWIG_arg_fail(1)) SWIG_fail;
27613 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27614 if (SWIG_arg_fail(2)) SWIG_fail;
27615 {
27616 PyThreadState* __tstate = wxPyBeginAllowThreads();
27617 (arg1)->PushEventHandler(arg2);
27618
27619 wxPyEndAllowThreads(__tstate);
27620 if (PyErr_Occurred()) SWIG_fail;
27621 }
27622 Py_INCREF(Py_None); resultobj = Py_None;
27623 return resultobj;
27624 fail:
27625 return NULL;
27626 }
27627
27628
27629 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27630 PyObject *resultobj;
27631 wxWindow *arg1 = (wxWindow *) 0 ;
27632 bool arg2 = (bool) false ;
27633 wxEvtHandler *result;
27634 PyObject * obj0 = 0 ;
27635 PyObject * obj1 = 0 ;
27636 char *kwnames[] = {
27637 (char *) "self",(char *) "deleteHandler", NULL
27638 };
27639
27640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
27641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27642 if (SWIG_arg_fail(1)) SWIG_fail;
27643 if (obj1) {
27644 {
27645 arg2 = (bool)(SWIG_As_bool(obj1));
27646 if (SWIG_arg_fail(2)) SWIG_fail;
27647 }
27648 }
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
27652
27653 wxPyEndAllowThreads(__tstate);
27654 if (PyErr_Occurred()) SWIG_fail;
27655 }
27656 {
27657 resultobj = wxPyMake_wxObject(result, 0);
27658 }
27659 return resultobj;
27660 fail:
27661 return NULL;
27662 }
27663
27664
27665 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27666 PyObject *resultobj;
27667 wxWindow *arg1 = (wxWindow *) 0 ;
27668 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27669 bool result;
27670 PyObject * obj0 = 0 ;
27671 PyObject * obj1 = 0 ;
27672 char *kwnames[] = {
27673 (char *) "self",(char *) "handler", NULL
27674 };
27675
27676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
27677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27678 if (SWIG_arg_fail(1)) SWIG_fail;
27679 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27680 if (SWIG_arg_fail(2)) SWIG_fail;
27681 {
27682 PyThreadState* __tstate = wxPyBeginAllowThreads();
27683 result = (bool)(arg1)->RemoveEventHandler(arg2);
27684
27685 wxPyEndAllowThreads(__tstate);
27686 if (PyErr_Occurred()) SWIG_fail;
27687 }
27688 {
27689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27690 }
27691 return resultobj;
27692 fail:
27693 return NULL;
27694 }
27695
27696
27697 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27698 PyObject *resultobj;
27699 wxWindow *arg1 = (wxWindow *) 0 ;
27700 wxValidator *arg2 = 0 ;
27701 PyObject * obj0 = 0 ;
27702 PyObject * obj1 = 0 ;
27703 char *kwnames[] = {
27704 (char *) "self",(char *) "validator", NULL
27705 };
27706
27707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
27708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27709 if (SWIG_arg_fail(1)) SWIG_fail;
27710 {
27711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
27712 if (SWIG_arg_fail(2)) SWIG_fail;
27713 if (arg2 == NULL) {
27714 SWIG_null_ref("wxValidator");
27715 }
27716 if (SWIG_arg_fail(2)) SWIG_fail;
27717 }
27718 {
27719 PyThreadState* __tstate = wxPyBeginAllowThreads();
27720 (arg1)->SetValidator((wxValidator const &)*arg2);
27721
27722 wxPyEndAllowThreads(__tstate);
27723 if (PyErr_Occurred()) SWIG_fail;
27724 }
27725 Py_INCREF(Py_None); resultobj = Py_None;
27726 return resultobj;
27727 fail:
27728 return NULL;
27729 }
27730
27731
27732 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27733 PyObject *resultobj;
27734 wxWindow *arg1 = (wxWindow *) 0 ;
27735 wxValidator *result;
27736 PyObject * obj0 = 0 ;
27737 char *kwnames[] = {
27738 (char *) "self", NULL
27739 };
27740
27741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
27742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27743 if (SWIG_arg_fail(1)) SWIG_fail;
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 result = (wxValidator *)(arg1)->GetValidator();
27747
27748 wxPyEndAllowThreads(__tstate);
27749 if (PyErr_Occurred()) SWIG_fail;
27750 }
27751 {
27752 resultobj = wxPyMake_wxObject(result, 0);
27753 }
27754 return resultobj;
27755 fail:
27756 return NULL;
27757 }
27758
27759
27760 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
27761 PyObject *resultobj;
27762 wxWindow *arg1 = (wxWindow *) 0 ;
27763 bool result;
27764 PyObject * obj0 = 0 ;
27765 char *kwnames[] = {
27766 (char *) "self", NULL
27767 };
27768
27769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
27770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27771 if (SWIG_arg_fail(1)) SWIG_fail;
27772 {
27773 PyThreadState* __tstate = wxPyBeginAllowThreads();
27774 result = (bool)(arg1)->Validate();
27775
27776 wxPyEndAllowThreads(__tstate);
27777 if (PyErr_Occurred()) SWIG_fail;
27778 }
27779 {
27780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27781 }
27782 return resultobj;
27783 fail:
27784 return NULL;
27785 }
27786
27787
27788 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27789 PyObject *resultobj;
27790 wxWindow *arg1 = (wxWindow *) 0 ;
27791 bool result;
27792 PyObject * obj0 = 0 ;
27793 char *kwnames[] = {
27794 (char *) "self", NULL
27795 };
27796
27797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
27798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27799 if (SWIG_arg_fail(1)) SWIG_fail;
27800 {
27801 PyThreadState* __tstate = wxPyBeginAllowThreads();
27802 result = (bool)(arg1)->TransferDataToWindow();
27803
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 {
27808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27809 }
27810 return resultobj;
27811 fail:
27812 return NULL;
27813 }
27814
27815
27816 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
27817 PyObject *resultobj;
27818 wxWindow *arg1 = (wxWindow *) 0 ;
27819 bool result;
27820 PyObject * obj0 = 0 ;
27821 char *kwnames[] = {
27822 (char *) "self", NULL
27823 };
27824
27825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
27826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27827 if (SWIG_arg_fail(1)) SWIG_fail;
27828 {
27829 PyThreadState* __tstate = wxPyBeginAllowThreads();
27830 result = (bool)(arg1)->TransferDataFromWindow();
27831
27832 wxPyEndAllowThreads(__tstate);
27833 if (PyErr_Occurred()) SWIG_fail;
27834 }
27835 {
27836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27837 }
27838 return resultobj;
27839 fail:
27840 return NULL;
27841 }
27842
27843
27844 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
27845 PyObject *resultobj;
27846 wxWindow *arg1 = (wxWindow *) 0 ;
27847 PyObject * obj0 = 0 ;
27848 char *kwnames[] = {
27849 (char *) "self", NULL
27850 };
27851
27852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
27853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27854 if (SWIG_arg_fail(1)) SWIG_fail;
27855 {
27856 PyThreadState* __tstate = wxPyBeginAllowThreads();
27857 (arg1)->InitDialog();
27858
27859 wxPyEndAllowThreads(__tstate);
27860 if (PyErr_Occurred()) SWIG_fail;
27861 }
27862 Py_INCREF(Py_None); resultobj = Py_None;
27863 return resultobj;
27864 fail:
27865 return NULL;
27866 }
27867
27868
27869 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
27870 PyObject *resultobj;
27871 wxWindow *arg1 = (wxWindow *) 0 ;
27872 wxAcceleratorTable *arg2 = 0 ;
27873 PyObject * obj0 = 0 ;
27874 PyObject * obj1 = 0 ;
27875 char *kwnames[] = {
27876 (char *) "self",(char *) "accel", NULL
27877 };
27878
27879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
27880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27881 if (SWIG_arg_fail(1)) SWIG_fail;
27882 {
27883 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
27884 if (SWIG_arg_fail(2)) SWIG_fail;
27885 if (arg2 == NULL) {
27886 SWIG_null_ref("wxAcceleratorTable");
27887 }
27888 if (SWIG_arg_fail(2)) SWIG_fail;
27889 }
27890 {
27891 PyThreadState* __tstate = wxPyBeginAllowThreads();
27892 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
27893
27894 wxPyEndAllowThreads(__tstate);
27895 if (PyErr_Occurred()) SWIG_fail;
27896 }
27897 Py_INCREF(Py_None); resultobj = Py_None;
27898 return resultobj;
27899 fail:
27900 return NULL;
27901 }
27902
27903
27904 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
27905 PyObject *resultobj;
27906 wxWindow *arg1 = (wxWindow *) 0 ;
27907 wxAcceleratorTable *result;
27908 PyObject * obj0 = 0 ;
27909 char *kwnames[] = {
27910 (char *) "self", NULL
27911 };
27912
27913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
27914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27915 if (SWIG_arg_fail(1)) SWIG_fail;
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
27919
27920 wxPyEndAllowThreads(__tstate);
27921 if (PyErr_Occurred()) SWIG_fail;
27922 }
27923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
27924 return resultobj;
27925 fail:
27926 return NULL;
27927 }
27928
27929
27930 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
27931 PyObject *resultobj;
27932 wxWindow *arg1 = (wxWindow *) 0 ;
27933 int arg2 ;
27934 int arg3 ;
27935 int arg4 ;
27936 bool result;
27937 PyObject * obj0 = 0 ;
27938 PyObject * obj1 = 0 ;
27939 PyObject * obj2 = 0 ;
27940 PyObject * obj3 = 0 ;
27941 char *kwnames[] = {
27942 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
27943 };
27944
27945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27947 if (SWIG_arg_fail(1)) SWIG_fail;
27948 {
27949 arg2 = (int)(SWIG_As_int(obj1));
27950 if (SWIG_arg_fail(2)) SWIG_fail;
27951 }
27952 {
27953 arg3 = (int)(SWIG_As_int(obj2));
27954 if (SWIG_arg_fail(3)) SWIG_fail;
27955 }
27956 {
27957 arg4 = (int)(SWIG_As_int(obj3));
27958 if (SWIG_arg_fail(4)) SWIG_fail;
27959 }
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
27963
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 {
27968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27969 }
27970 return resultobj;
27971 fail:
27972 return NULL;
27973 }
27974
27975
27976 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
27977 PyObject *resultobj;
27978 wxWindow *arg1 = (wxWindow *) 0 ;
27979 int arg2 ;
27980 bool result;
27981 PyObject * obj0 = 0 ;
27982 PyObject * obj1 = 0 ;
27983 char *kwnames[] = {
27984 (char *) "self",(char *) "hotkeyId", NULL
27985 };
27986
27987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
27988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27989 if (SWIG_arg_fail(1)) SWIG_fail;
27990 {
27991 arg2 = (int)(SWIG_As_int(obj1));
27992 if (SWIG_arg_fail(2)) SWIG_fail;
27993 }
27994 {
27995 PyThreadState* __tstate = wxPyBeginAllowThreads();
27996 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
27997
27998 wxPyEndAllowThreads(__tstate);
27999 if (PyErr_Occurred()) SWIG_fail;
28000 }
28001 {
28002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28003 }
28004 return resultobj;
28005 fail:
28006 return NULL;
28007 }
28008
28009
28010 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28011 PyObject *resultobj;
28012 wxWindow *arg1 = (wxWindow *) 0 ;
28013 wxPoint *arg2 = 0 ;
28014 wxPoint result;
28015 wxPoint temp2 ;
28016 PyObject * obj0 = 0 ;
28017 PyObject * obj1 = 0 ;
28018 char *kwnames[] = {
28019 (char *) "self",(char *) "pt", NULL
28020 };
28021
28022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28024 if (SWIG_arg_fail(1)) SWIG_fail;
28025 {
28026 arg2 = &temp2;
28027 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28028 }
28029 {
28030 PyThreadState* __tstate = wxPyBeginAllowThreads();
28031 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28032
28033 wxPyEndAllowThreads(__tstate);
28034 if (PyErr_Occurred()) SWIG_fail;
28035 }
28036 {
28037 wxPoint * resultptr;
28038 resultptr = new wxPoint((wxPoint &)(result));
28039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28040 }
28041 return resultobj;
28042 fail:
28043 return NULL;
28044 }
28045
28046
28047 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28048 PyObject *resultobj;
28049 wxWindow *arg1 = (wxWindow *) 0 ;
28050 wxSize *arg2 = 0 ;
28051 wxSize result;
28052 wxSize temp2 ;
28053 PyObject * obj0 = 0 ;
28054 PyObject * obj1 = 0 ;
28055 char *kwnames[] = {
28056 (char *) "self",(char *) "sz", NULL
28057 };
28058
28059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28061 if (SWIG_arg_fail(1)) SWIG_fail;
28062 {
28063 arg2 = &temp2;
28064 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28065 }
28066 {
28067 PyThreadState* __tstate = wxPyBeginAllowThreads();
28068 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28069
28070 wxPyEndAllowThreads(__tstate);
28071 if (PyErr_Occurred()) SWIG_fail;
28072 }
28073 {
28074 wxSize * resultptr;
28075 resultptr = new wxSize((wxSize &)(result));
28076 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28077 }
28078 return resultobj;
28079 fail:
28080 return NULL;
28081 }
28082
28083
28084 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28085 PyObject *resultobj;
28086 wxWindow *arg1 = (wxWindow *) 0 ;
28087 wxPoint *arg2 = 0 ;
28088 wxPoint result;
28089 wxPoint temp2 ;
28090 PyObject * obj0 = 0 ;
28091 PyObject * obj1 = 0 ;
28092 char *kwnames[] = {
28093 (char *) "self",(char *) "pt", NULL
28094 };
28095
28096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",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 {
28100 arg2 = &temp2;
28101 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28102 }
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28106
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 {
28111 wxPoint * resultptr;
28112 resultptr = new wxPoint((wxPoint &)(result));
28113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28114 }
28115 return resultobj;
28116 fail:
28117 return NULL;
28118 }
28119
28120
28121 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28122 PyObject *resultobj;
28123 wxWindow *arg1 = (wxWindow *) 0 ;
28124 wxSize *arg2 = 0 ;
28125 wxSize result;
28126 wxSize temp2 ;
28127 PyObject * obj0 = 0 ;
28128 PyObject * obj1 = 0 ;
28129 char *kwnames[] = {
28130 (char *) "self",(char *) "sz", NULL
28131 };
28132
28133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28135 if (SWIG_arg_fail(1)) SWIG_fail;
28136 {
28137 arg2 = &temp2;
28138 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28139 }
28140 {
28141 PyThreadState* __tstate = wxPyBeginAllowThreads();
28142 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28143
28144 wxPyEndAllowThreads(__tstate);
28145 if (PyErr_Occurred()) SWIG_fail;
28146 }
28147 {
28148 wxSize * resultptr;
28149 resultptr = new wxSize((wxSize &)(result));
28150 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28151 }
28152 return resultobj;
28153 fail:
28154 return NULL;
28155 }
28156
28157
28158 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28159 PyObject *resultobj;
28160 wxWindow *arg1 = (wxWindow *) 0 ;
28161 wxPoint *arg2 = 0 ;
28162 wxPoint result;
28163 wxPoint temp2 ;
28164 PyObject * obj0 = 0 ;
28165 PyObject * obj1 = 0 ;
28166 char *kwnames[] = {
28167 (char *) "self",(char *) "pt", NULL
28168 };
28169
28170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28172 if (SWIG_arg_fail(1)) SWIG_fail;
28173 {
28174 arg2 = &temp2;
28175 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28176 }
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28180
28181 wxPyEndAllowThreads(__tstate);
28182 if (PyErr_Occurred()) SWIG_fail;
28183 }
28184 {
28185 wxPoint * resultptr;
28186 resultptr = new wxPoint((wxPoint &)(result));
28187 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28188 }
28189 return resultobj;
28190 fail:
28191 return NULL;
28192 }
28193
28194
28195 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28196 PyObject *resultobj;
28197 wxWindow *arg1 = (wxWindow *) 0 ;
28198 wxSize *arg2 = 0 ;
28199 wxSize result;
28200 wxSize temp2 ;
28201 PyObject * obj0 = 0 ;
28202 PyObject * obj1 = 0 ;
28203 char *kwnames[] = {
28204 (char *) "self",(char *) "sz", NULL
28205 };
28206
28207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
28212 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28213 }
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28217
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 {
28222 wxSize * resultptr;
28223 resultptr = new wxSize((wxSize &)(result));
28224 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28225 }
28226 return resultobj;
28227 fail:
28228 return NULL;
28229 }
28230
28231
28232 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28233 PyObject *resultobj;
28234 wxWindow *arg1 = (wxWindow *) 0 ;
28235 int arg2 ;
28236 int arg3 ;
28237 PyObject * obj0 = 0 ;
28238 PyObject * obj1 = 0 ;
28239 PyObject * obj2 = 0 ;
28240 char *kwnames[] = {
28241 (char *) "self",(char *) "x",(char *) "y", NULL
28242 };
28243
28244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28246 if (SWIG_arg_fail(1)) SWIG_fail;
28247 {
28248 arg2 = (int)(SWIG_As_int(obj1));
28249 if (SWIG_arg_fail(2)) SWIG_fail;
28250 }
28251 {
28252 arg3 = (int)(SWIG_As_int(obj2));
28253 if (SWIG_arg_fail(3)) SWIG_fail;
28254 }
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 (arg1)->WarpPointer(arg2,arg3);
28258
28259 wxPyEndAllowThreads(__tstate);
28260 if (PyErr_Occurred()) SWIG_fail;
28261 }
28262 Py_INCREF(Py_None); resultobj = Py_None;
28263 return resultobj;
28264 fail:
28265 return NULL;
28266 }
28267
28268
28269 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28270 PyObject *resultobj;
28271 wxWindow *arg1 = (wxWindow *) 0 ;
28272 PyObject * obj0 = 0 ;
28273 char *kwnames[] = {
28274 (char *) "self", NULL
28275 };
28276
28277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28279 if (SWIG_arg_fail(1)) SWIG_fail;
28280 {
28281 PyThreadState* __tstate = wxPyBeginAllowThreads();
28282 (arg1)->CaptureMouse();
28283
28284 wxPyEndAllowThreads(__tstate);
28285 if (PyErr_Occurred()) SWIG_fail;
28286 }
28287 Py_INCREF(Py_None); resultobj = Py_None;
28288 return resultobj;
28289 fail:
28290 return NULL;
28291 }
28292
28293
28294 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28295 PyObject *resultobj;
28296 wxWindow *arg1 = (wxWindow *) 0 ;
28297 PyObject * obj0 = 0 ;
28298 char *kwnames[] = {
28299 (char *) "self", NULL
28300 };
28301
28302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28304 if (SWIG_arg_fail(1)) SWIG_fail;
28305 {
28306 PyThreadState* __tstate = wxPyBeginAllowThreads();
28307 (arg1)->ReleaseMouse();
28308
28309 wxPyEndAllowThreads(__tstate);
28310 if (PyErr_Occurred()) SWIG_fail;
28311 }
28312 Py_INCREF(Py_None); resultobj = Py_None;
28313 return resultobj;
28314 fail:
28315 return NULL;
28316 }
28317
28318
28319 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28320 PyObject *resultobj;
28321 wxWindow *result;
28322 char *kwnames[] = {
28323 NULL
28324 };
28325
28326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28327 {
28328 if (!wxPyCheckForApp()) SWIG_fail;
28329 PyThreadState* __tstate = wxPyBeginAllowThreads();
28330 result = (wxWindow *)wxWindow::GetCapture();
28331
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 {
28336 resultobj = wxPyMake_wxObject(result, 0);
28337 }
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28345 PyObject *resultobj;
28346 wxWindow *arg1 = (wxWindow *) 0 ;
28347 bool result;
28348 PyObject * obj0 = 0 ;
28349 char *kwnames[] = {
28350 (char *) "self", NULL
28351 };
28352
28353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28355 if (SWIG_arg_fail(1)) SWIG_fail;
28356 {
28357 PyThreadState* __tstate = wxPyBeginAllowThreads();
28358 result = (bool)((wxWindow const *)arg1)->HasCapture();
28359
28360 wxPyEndAllowThreads(__tstate);
28361 if (PyErr_Occurred()) SWIG_fail;
28362 }
28363 {
28364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28365 }
28366 return resultobj;
28367 fail:
28368 return NULL;
28369 }
28370
28371
28372 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28373 PyObject *resultobj;
28374 wxWindow *arg1 = (wxWindow *) 0 ;
28375 bool arg2 = (bool) true ;
28376 wxRect *arg3 = (wxRect *) NULL ;
28377 PyObject * obj0 = 0 ;
28378 PyObject * obj1 = 0 ;
28379 PyObject * obj2 = 0 ;
28380 char *kwnames[] = {
28381 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28382 };
28383
28384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28386 if (SWIG_arg_fail(1)) SWIG_fail;
28387 if (obj1) {
28388 {
28389 arg2 = (bool)(SWIG_As_bool(obj1));
28390 if (SWIG_arg_fail(2)) SWIG_fail;
28391 }
28392 }
28393 if (obj2) {
28394 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28395 if (SWIG_arg_fail(3)) SWIG_fail;
28396 }
28397 {
28398 PyThreadState* __tstate = wxPyBeginAllowThreads();
28399 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28400
28401 wxPyEndAllowThreads(__tstate);
28402 if (PyErr_Occurred()) SWIG_fail;
28403 }
28404 Py_INCREF(Py_None); resultobj = Py_None;
28405 return resultobj;
28406 fail:
28407 return NULL;
28408 }
28409
28410
28411 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28412 PyObject *resultobj;
28413 wxWindow *arg1 = (wxWindow *) 0 ;
28414 wxRect *arg2 = 0 ;
28415 wxRect temp2 ;
28416 PyObject * obj0 = 0 ;
28417 PyObject * obj1 = 0 ;
28418 char *kwnames[] = {
28419 (char *) "self",(char *) "rect", NULL
28420 };
28421
28422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RefreshRect",kwnames,&obj0,&obj1)) goto fail;
28423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28424 if (SWIG_arg_fail(1)) SWIG_fail;
28425 {
28426 arg2 = &temp2;
28427 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28428 }
28429 {
28430 PyThreadState* __tstate = wxPyBeginAllowThreads();
28431 (arg1)->RefreshRect((wxRect const &)*arg2);
28432
28433 wxPyEndAllowThreads(__tstate);
28434 if (PyErr_Occurred()) SWIG_fail;
28435 }
28436 Py_INCREF(Py_None); resultobj = Py_None;
28437 return resultobj;
28438 fail:
28439 return NULL;
28440 }
28441
28442
28443 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28444 PyObject *resultobj;
28445 wxWindow *arg1 = (wxWindow *) 0 ;
28446 PyObject * obj0 = 0 ;
28447 char *kwnames[] = {
28448 (char *) "self", NULL
28449 };
28450
28451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28453 if (SWIG_arg_fail(1)) SWIG_fail;
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 (arg1)->Update();
28457
28458 wxPyEndAllowThreads(__tstate);
28459 if (PyErr_Occurred()) SWIG_fail;
28460 }
28461 Py_INCREF(Py_None); resultobj = Py_None;
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28469 PyObject *resultobj;
28470 wxWindow *arg1 = (wxWindow *) 0 ;
28471 PyObject * obj0 = 0 ;
28472 char *kwnames[] = {
28473 (char *) "self", NULL
28474 };
28475
28476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28478 if (SWIG_arg_fail(1)) SWIG_fail;
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 (arg1)->ClearBackground();
28482
28483 wxPyEndAllowThreads(__tstate);
28484 if (PyErr_Occurred()) SWIG_fail;
28485 }
28486 Py_INCREF(Py_None); resultobj = Py_None;
28487 return resultobj;
28488 fail:
28489 return NULL;
28490 }
28491
28492
28493 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28494 PyObject *resultobj;
28495 wxWindow *arg1 = (wxWindow *) 0 ;
28496 PyObject * obj0 = 0 ;
28497 char *kwnames[] = {
28498 (char *) "self", NULL
28499 };
28500
28501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28503 if (SWIG_arg_fail(1)) SWIG_fail;
28504 {
28505 PyThreadState* __tstate = wxPyBeginAllowThreads();
28506 (arg1)->Freeze();
28507
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 Py_INCREF(Py_None); resultobj = Py_None;
28512 return resultobj;
28513 fail:
28514 return NULL;
28515 }
28516
28517
28518 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28519 PyObject *resultobj;
28520 wxWindow *arg1 = (wxWindow *) 0 ;
28521 PyObject * obj0 = 0 ;
28522 char *kwnames[] = {
28523 (char *) "self", NULL
28524 };
28525
28526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28528 if (SWIG_arg_fail(1)) SWIG_fail;
28529 {
28530 PyThreadState* __tstate = wxPyBeginAllowThreads();
28531 (arg1)->Thaw();
28532
28533 wxPyEndAllowThreads(__tstate);
28534 if (PyErr_Occurred()) SWIG_fail;
28535 }
28536 Py_INCREF(Py_None); resultobj = Py_None;
28537 return resultobj;
28538 fail:
28539 return NULL;
28540 }
28541
28542
28543 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28544 PyObject *resultobj;
28545 wxWindow *arg1 = (wxWindow *) 0 ;
28546 wxDC *arg2 = 0 ;
28547 PyObject * obj0 = 0 ;
28548 PyObject * obj1 = 0 ;
28549 char *kwnames[] = {
28550 (char *) "self",(char *) "dc", NULL
28551 };
28552
28553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28555 if (SWIG_arg_fail(1)) SWIG_fail;
28556 {
28557 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28558 if (SWIG_arg_fail(2)) SWIG_fail;
28559 if (arg2 == NULL) {
28560 SWIG_null_ref("wxDC");
28561 }
28562 if (SWIG_arg_fail(2)) SWIG_fail;
28563 }
28564 {
28565 PyThreadState* __tstate = wxPyBeginAllowThreads();
28566 (arg1)->PrepareDC(*arg2);
28567
28568 wxPyEndAllowThreads(__tstate);
28569 if (PyErr_Occurred()) SWIG_fail;
28570 }
28571 Py_INCREF(Py_None); resultobj = Py_None;
28572 return resultobj;
28573 fail:
28574 return NULL;
28575 }
28576
28577
28578 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28579 PyObject *resultobj;
28580 wxWindow *arg1 = (wxWindow *) 0 ;
28581 wxRegion *result;
28582 PyObject * obj0 = 0 ;
28583 char *kwnames[] = {
28584 (char *) "self", NULL
28585 };
28586
28587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28589 if (SWIG_arg_fail(1)) SWIG_fail;
28590 {
28591 PyThreadState* __tstate = wxPyBeginAllowThreads();
28592 {
28593 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28594 result = (wxRegion *) &_result_ref;
28595 }
28596
28597 wxPyEndAllowThreads(__tstate);
28598 if (PyErr_Occurred()) SWIG_fail;
28599 }
28600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28601 return resultobj;
28602 fail:
28603 return NULL;
28604 }
28605
28606
28607 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28608 PyObject *resultobj;
28609 wxWindow *arg1 = (wxWindow *) 0 ;
28610 wxRect result;
28611 PyObject * obj0 = 0 ;
28612 char *kwnames[] = {
28613 (char *) "self", NULL
28614 };
28615
28616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28618 if (SWIG_arg_fail(1)) SWIG_fail;
28619 {
28620 PyThreadState* __tstate = wxPyBeginAllowThreads();
28621 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28622
28623 wxPyEndAllowThreads(__tstate);
28624 if (PyErr_Occurred()) SWIG_fail;
28625 }
28626 {
28627 wxRect * resultptr;
28628 resultptr = new wxRect((wxRect &)(result));
28629 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28630 }
28631 return resultobj;
28632 fail:
28633 return NULL;
28634 }
28635
28636
28637 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
28638 PyObject *resultobj;
28639 wxWindow *arg1 = (wxWindow *) 0 ;
28640 int arg2 ;
28641 int arg3 ;
28642 int arg4 = (int) 1 ;
28643 int arg5 = (int) 1 ;
28644 bool result;
28645 PyObject * obj0 = 0 ;
28646 PyObject * obj1 = 0 ;
28647 PyObject * obj2 = 0 ;
28648 PyObject * obj3 = 0 ;
28649 PyObject * obj4 = 0 ;
28650 char *kwnames[] = {
28651 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
28652 };
28653
28654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
28655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28656 if (SWIG_arg_fail(1)) SWIG_fail;
28657 {
28658 arg2 = (int)(SWIG_As_int(obj1));
28659 if (SWIG_arg_fail(2)) SWIG_fail;
28660 }
28661 {
28662 arg3 = (int)(SWIG_As_int(obj2));
28663 if (SWIG_arg_fail(3)) SWIG_fail;
28664 }
28665 if (obj3) {
28666 {
28667 arg4 = (int)(SWIG_As_int(obj3));
28668 if (SWIG_arg_fail(4)) SWIG_fail;
28669 }
28670 }
28671 if (obj4) {
28672 {
28673 arg5 = (int)(SWIG_As_int(obj4));
28674 if (SWIG_arg_fail(5)) SWIG_fail;
28675 }
28676 }
28677 {
28678 PyThreadState* __tstate = wxPyBeginAllowThreads();
28679 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
28680
28681 wxPyEndAllowThreads(__tstate);
28682 if (PyErr_Occurred()) SWIG_fail;
28683 }
28684 {
28685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28686 }
28687 return resultobj;
28688 fail:
28689 return NULL;
28690 }
28691
28692
28693 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
28694 PyObject *resultobj;
28695 wxWindow *arg1 = (wxWindow *) 0 ;
28696 wxPoint *arg2 = 0 ;
28697 bool result;
28698 wxPoint temp2 ;
28699 PyObject * obj0 = 0 ;
28700 PyObject * obj1 = 0 ;
28701 char *kwnames[] = {
28702 (char *) "self",(char *) "pt", NULL
28703 };
28704
28705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
28706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28707 if (SWIG_arg_fail(1)) SWIG_fail;
28708 {
28709 arg2 = &temp2;
28710 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28711 }
28712 {
28713 PyThreadState* __tstate = wxPyBeginAllowThreads();
28714 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
28715
28716 wxPyEndAllowThreads(__tstate);
28717 if (PyErr_Occurred()) SWIG_fail;
28718 }
28719 {
28720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28721 }
28722 return resultobj;
28723 fail:
28724 return NULL;
28725 }
28726
28727
28728 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
28729 PyObject *resultobj;
28730 wxWindow *arg1 = (wxWindow *) 0 ;
28731 wxRect *arg2 = 0 ;
28732 bool result;
28733 wxRect temp2 ;
28734 PyObject * obj0 = 0 ;
28735 PyObject * obj1 = 0 ;
28736 char *kwnames[] = {
28737 (char *) "self",(char *) "rect", NULL
28738 };
28739
28740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
28741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28742 if (SWIG_arg_fail(1)) SWIG_fail;
28743 {
28744 arg2 = &temp2;
28745 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28746 }
28747 {
28748 PyThreadState* __tstate = wxPyBeginAllowThreads();
28749 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
28750
28751 wxPyEndAllowThreads(__tstate);
28752 if (PyErr_Occurred()) SWIG_fail;
28753 }
28754 {
28755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28756 }
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28764 PyObject *resultobj;
28765 wxWindow *arg1 = (wxWindow *) 0 ;
28766 wxVisualAttributes result;
28767 PyObject * obj0 = 0 ;
28768 char *kwnames[] = {
28769 (char *) "self", NULL
28770 };
28771
28772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
28773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28774 if (SWIG_arg_fail(1)) SWIG_fail;
28775 {
28776 PyThreadState* __tstate = wxPyBeginAllowThreads();
28777 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
28778
28779 wxPyEndAllowThreads(__tstate);
28780 if (PyErr_Occurred()) SWIG_fail;
28781 }
28782 {
28783 wxVisualAttributes * resultptr;
28784 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28785 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28786 }
28787 return resultobj;
28788 fail:
28789 return NULL;
28790 }
28791
28792
28793 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
28794 PyObject *resultobj;
28795 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
28796 wxVisualAttributes result;
28797 PyObject * obj0 = 0 ;
28798 char *kwnames[] = {
28799 (char *) "variant", NULL
28800 };
28801
28802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
28803 if (obj0) {
28804 {
28805 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
28806 if (SWIG_arg_fail(1)) SWIG_fail;
28807 }
28808 }
28809 {
28810 if (!wxPyCheckForApp()) SWIG_fail;
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
28813
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 {
28818 wxVisualAttributes * resultptr;
28819 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
28820 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
28821 }
28822 return resultobj;
28823 fail:
28824 return NULL;
28825 }
28826
28827
28828 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28829 PyObject *resultobj;
28830 wxWindow *arg1 = (wxWindow *) 0 ;
28831 wxColour *arg2 = 0 ;
28832 bool result;
28833 wxColour temp2 ;
28834 PyObject * obj0 = 0 ;
28835 PyObject * obj1 = 0 ;
28836 char *kwnames[] = {
28837 (char *) "self",(char *) "colour", NULL
28838 };
28839
28840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28842 if (SWIG_arg_fail(1)) SWIG_fail;
28843 {
28844 arg2 = &temp2;
28845 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28846 }
28847 {
28848 PyThreadState* __tstate = wxPyBeginAllowThreads();
28849 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
28850
28851 wxPyEndAllowThreads(__tstate);
28852 if (PyErr_Occurred()) SWIG_fail;
28853 }
28854 {
28855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28856 }
28857 return resultobj;
28858 fail:
28859 return NULL;
28860 }
28861
28862
28863 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28864 PyObject *resultobj;
28865 wxWindow *arg1 = (wxWindow *) 0 ;
28866 wxColour *arg2 = 0 ;
28867 wxColour temp2 ;
28868 PyObject * obj0 = 0 ;
28869 PyObject * obj1 = 0 ;
28870 char *kwnames[] = {
28871 (char *) "self",(char *) "colour", NULL
28872 };
28873
28874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
28875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28876 if (SWIG_arg_fail(1)) SWIG_fail;
28877 {
28878 arg2 = &temp2;
28879 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28880 }
28881 {
28882 PyThreadState* __tstate = wxPyBeginAllowThreads();
28883 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
28884
28885 wxPyEndAllowThreads(__tstate);
28886 if (PyErr_Occurred()) SWIG_fail;
28887 }
28888 Py_INCREF(Py_None); resultobj = Py_None;
28889 return resultobj;
28890 fail:
28891 return NULL;
28892 }
28893
28894
28895 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28896 PyObject *resultobj;
28897 wxWindow *arg1 = (wxWindow *) 0 ;
28898 wxColour *arg2 = 0 ;
28899 bool result;
28900 wxColour temp2 ;
28901 PyObject * obj0 = 0 ;
28902 PyObject * obj1 = 0 ;
28903 char *kwnames[] = {
28904 (char *) "self",(char *) "colour", NULL
28905 };
28906
28907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
28908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28909 if (SWIG_arg_fail(1)) SWIG_fail;
28910 {
28911 arg2 = &temp2;
28912 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28913 }
28914 {
28915 PyThreadState* __tstate = wxPyBeginAllowThreads();
28916 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
28917
28918 wxPyEndAllowThreads(__tstate);
28919 if (PyErr_Occurred()) SWIG_fail;
28920 }
28921 {
28922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28923 }
28924 return resultobj;
28925 fail:
28926 return NULL;
28927 }
28928
28929
28930 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28931 PyObject *resultobj;
28932 wxWindow *arg1 = (wxWindow *) 0 ;
28933 wxColour *arg2 = 0 ;
28934 wxColour temp2 ;
28935 PyObject * obj0 = 0 ;
28936 PyObject * obj1 = 0 ;
28937 char *kwnames[] = {
28938 (char *) "self",(char *) "colour", NULL
28939 };
28940
28941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
28942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28943 if (SWIG_arg_fail(1)) SWIG_fail;
28944 {
28945 arg2 = &temp2;
28946 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
28947 }
28948 {
28949 PyThreadState* __tstate = wxPyBeginAllowThreads();
28950 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
28951
28952 wxPyEndAllowThreads(__tstate);
28953 if (PyErr_Occurred()) SWIG_fail;
28954 }
28955 Py_INCREF(Py_None); resultobj = Py_None;
28956 return resultobj;
28957 fail:
28958 return NULL;
28959 }
28960
28961
28962 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28963 PyObject *resultobj;
28964 wxWindow *arg1 = (wxWindow *) 0 ;
28965 wxColour result;
28966 PyObject * obj0 = 0 ;
28967 char *kwnames[] = {
28968 (char *) "self", NULL
28969 };
28970
28971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
28972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28973 if (SWIG_arg_fail(1)) SWIG_fail;
28974 {
28975 PyThreadState* __tstate = wxPyBeginAllowThreads();
28976 result = ((wxWindow const *)arg1)->GetBackgroundColour();
28977
28978 wxPyEndAllowThreads(__tstate);
28979 if (PyErr_Occurred()) SWIG_fail;
28980 }
28981 {
28982 wxColour * resultptr;
28983 resultptr = new wxColour((wxColour &)(result));
28984 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
28985 }
28986 return resultobj;
28987 fail:
28988 return NULL;
28989 }
28990
28991
28992 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
28993 PyObject *resultobj;
28994 wxWindow *arg1 = (wxWindow *) 0 ;
28995 wxColour result;
28996 PyObject * obj0 = 0 ;
28997 char *kwnames[] = {
28998 (char *) "self", NULL
28999 };
29000
29001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29003 if (SWIG_arg_fail(1)) SWIG_fail;
29004 {
29005 PyThreadState* __tstate = wxPyBeginAllowThreads();
29006 result = ((wxWindow const *)arg1)->GetForegroundColour();
29007
29008 wxPyEndAllowThreads(__tstate);
29009 if (PyErr_Occurred()) SWIG_fail;
29010 }
29011 {
29012 wxColour * resultptr;
29013 resultptr = new wxColour((wxColour &)(result));
29014 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29015 }
29016 return resultobj;
29017 fail:
29018 return NULL;
29019 }
29020
29021
29022 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29023 PyObject *resultobj;
29024 wxWindow *arg1 = (wxWindow *) 0 ;
29025 wxBackgroundStyle arg2 ;
29026 bool result;
29027 PyObject * obj0 = 0 ;
29028 PyObject * obj1 = 0 ;
29029 char *kwnames[] = {
29030 (char *) "self",(char *) "style", NULL
29031 };
29032
29033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29035 if (SWIG_arg_fail(1)) SWIG_fail;
29036 {
29037 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29038 if (SWIG_arg_fail(2)) SWIG_fail;
29039 }
29040 {
29041 PyThreadState* __tstate = wxPyBeginAllowThreads();
29042 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29043
29044 wxPyEndAllowThreads(__tstate);
29045 if (PyErr_Occurred()) SWIG_fail;
29046 }
29047 {
29048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29049 }
29050 return resultobj;
29051 fail:
29052 return NULL;
29053 }
29054
29055
29056 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29057 PyObject *resultobj;
29058 wxWindow *arg1 = (wxWindow *) 0 ;
29059 wxBackgroundStyle result;
29060 PyObject * obj0 = 0 ;
29061 char *kwnames[] = {
29062 (char *) "self", NULL
29063 };
29064
29065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29067 if (SWIG_arg_fail(1)) SWIG_fail;
29068 {
29069 PyThreadState* __tstate = wxPyBeginAllowThreads();
29070 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29071
29072 wxPyEndAllowThreads(__tstate);
29073 if (PyErr_Occurred()) SWIG_fail;
29074 }
29075 resultobj = SWIG_From_int((result));
29076 return resultobj;
29077 fail:
29078 return NULL;
29079 }
29080
29081
29082 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29083 PyObject *resultobj;
29084 wxWindow *arg1 = (wxWindow *) 0 ;
29085 bool result;
29086 PyObject * obj0 = 0 ;
29087 char *kwnames[] = {
29088 (char *) "self", NULL
29089 };
29090
29091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29093 if (SWIG_arg_fail(1)) SWIG_fail;
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 result = (bool)(arg1)->HasTransparentBackground();
29097
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 {
29102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29103 }
29104 return resultobj;
29105 fail:
29106 return NULL;
29107 }
29108
29109
29110 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29111 PyObject *resultobj;
29112 wxWindow *arg1 = (wxWindow *) 0 ;
29113 wxCursor *arg2 = 0 ;
29114 bool result;
29115 PyObject * obj0 = 0 ;
29116 PyObject * obj1 = 0 ;
29117 char *kwnames[] = {
29118 (char *) "self",(char *) "cursor", NULL
29119 };
29120
29121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29123 if (SWIG_arg_fail(1)) SWIG_fail;
29124 {
29125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29126 if (SWIG_arg_fail(2)) SWIG_fail;
29127 if (arg2 == NULL) {
29128 SWIG_null_ref("wxCursor");
29129 }
29130 if (SWIG_arg_fail(2)) SWIG_fail;
29131 }
29132 {
29133 PyThreadState* __tstate = wxPyBeginAllowThreads();
29134 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29135
29136 wxPyEndAllowThreads(__tstate);
29137 if (PyErr_Occurred()) SWIG_fail;
29138 }
29139 {
29140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29141 }
29142 return resultobj;
29143 fail:
29144 return NULL;
29145 }
29146
29147
29148 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29149 PyObject *resultobj;
29150 wxWindow *arg1 = (wxWindow *) 0 ;
29151 wxCursor result;
29152 PyObject * obj0 = 0 ;
29153 char *kwnames[] = {
29154 (char *) "self", NULL
29155 };
29156
29157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29159 if (SWIG_arg_fail(1)) SWIG_fail;
29160 {
29161 PyThreadState* __tstate = wxPyBeginAllowThreads();
29162 result = (arg1)->GetCursor();
29163
29164 wxPyEndAllowThreads(__tstate);
29165 if (PyErr_Occurred()) SWIG_fail;
29166 }
29167 {
29168 wxCursor * resultptr;
29169 resultptr = new wxCursor((wxCursor &)(result));
29170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29171 }
29172 return resultobj;
29173 fail:
29174 return NULL;
29175 }
29176
29177
29178 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29179 PyObject *resultobj;
29180 wxWindow *arg1 = (wxWindow *) 0 ;
29181 wxFont *arg2 = 0 ;
29182 bool result;
29183 PyObject * obj0 = 0 ;
29184 PyObject * obj1 = 0 ;
29185 char *kwnames[] = {
29186 (char *) "self",(char *) "font", NULL
29187 };
29188
29189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29191 if (SWIG_arg_fail(1)) SWIG_fail;
29192 {
29193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29194 if (SWIG_arg_fail(2)) SWIG_fail;
29195 if (arg2 == NULL) {
29196 SWIG_null_ref("wxFont");
29197 }
29198 if (SWIG_arg_fail(2)) SWIG_fail;
29199 }
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29203
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 {
29208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29209 }
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29217 PyObject *resultobj;
29218 wxWindow *arg1 = (wxWindow *) 0 ;
29219 wxFont *arg2 = 0 ;
29220 PyObject * obj0 = 0 ;
29221 PyObject * obj1 = 0 ;
29222 char *kwnames[] = {
29223 (char *) "self",(char *) "font", NULL
29224 };
29225
29226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29228 if (SWIG_arg_fail(1)) SWIG_fail;
29229 {
29230 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29231 if (SWIG_arg_fail(2)) SWIG_fail;
29232 if (arg2 == NULL) {
29233 SWIG_null_ref("wxFont");
29234 }
29235 if (SWIG_arg_fail(2)) SWIG_fail;
29236 }
29237 {
29238 PyThreadState* __tstate = wxPyBeginAllowThreads();
29239 (arg1)->SetOwnFont((wxFont const &)*arg2);
29240
29241 wxPyEndAllowThreads(__tstate);
29242 if (PyErr_Occurred()) SWIG_fail;
29243 }
29244 Py_INCREF(Py_None); resultobj = Py_None;
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29252 PyObject *resultobj;
29253 wxWindow *arg1 = (wxWindow *) 0 ;
29254 wxFont result;
29255 PyObject * obj0 = 0 ;
29256 char *kwnames[] = {
29257 (char *) "self", NULL
29258 };
29259
29260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29262 if (SWIG_arg_fail(1)) SWIG_fail;
29263 {
29264 PyThreadState* __tstate = wxPyBeginAllowThreads();
29265 result = (arg1)->GetFont();
29266
29267 wxPyEndAllowThreads(__tstate);
29268 if (PyErr_Occurred()) SWIG_fail;
29269 }
29270 {
29271 wxFont * resultptr;
29272 resultptr = new wxFont((wxFont &)(result));
29273 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29274 }
29275 return resultobj;
29276 fail:
29277 return NULL;
29278 }
29279
29280
29281 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29282 PyObject *resultobj;
29283 wxWindow *arg1 = (wxWindow *) 0 ;
29284 wxCaret *arg2 = (wxCaret *) 0 ;
29285 PyObject * obj0 = 0 ;
29286 PyObject * obj1 = 0 ;
29287 char *kwnames[] = {
29288 (char *) "self",(char *) "caret", NULL
29289 };
29290
29291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29293 if (SWIG_arg_fail(1)) SWIG_fail;
29294 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29295 if (SWIG_arg_fail(2)) SWIG_fail;
29296 {
29297 PyThreadState* __tstate = wxPyBeginAllowThreads();
29298 (arg1)->SetCaret(arg2);
29299
29300 wxPyEndAllowThreads(__tstate);
29301 if (PyErr_Occurred()) SWIG_fail;
29302 }
29303 Py_INCREF(Py_None); resultobj = Py_None;
29304 return resultobj;
29305 fail:
29306 return NULL;
29307 }
29308
29309
29310 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29311 PyObject *resultobj;
29312 wxWindow *arg1 = (wxWindow *) 0 ;
29313 wxCaret *result;
29314 PyObject * obj0 = 0 ;
29315 char *kwnames[] = {
29316 (char *) "self", NULL
29317 };
29318
29319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29321 if (SWIG_arg_fail(1)) SWIG_fail;
29322 {
29323 PyThreadState* __tstate = wxPyBeginAllowThreads();
29324 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29325
29326 wxPyEndAllowThreads(__tstate);
29327 if (PyErr_Occurred()) SWIG_fail;
29328 }
29329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29330 return resultobj;
29331 fail:
29332 return NULL;
29333 }
29334
29335
29336 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29337 PyObject *resultobj;
29338 wxWindow *arg1 = (wxWindow *) 0 ;
29339 int result;
29340 PyObject * obj0 = 0 ;
29341 char *kwnames[] = {
29342 (char *) "self", NULL
29343 };
29344
29345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29347 if (SWIG_arg_fail(1)) SWIG_fail;
29348 {
29349 PyThreadState* __tstate = wxPyBeginAllowThreads();
29350 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29351
29352 wxPyEndAllowThreads(__tstate);
29353 if (PyErr_Occurred()) SWIG_fail;
29354 }
29355 {
29356 resultobj = SWIG_From_int((int)(result));
29357 }
29358 return resultobj;
29359 fail:
29360 return NULL;
29361 }
29362
29363
29364 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29365 PyObject *resultobj;
29366 wxWindow *arg1 = (wxWindow *) 0 ;
29367 int result;
29368 PyObject * obj0 = 0 ;
29369 char *kwnames[] = {
29370 (char *) "self", NULL
29371 };
29372
29373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29375 if (SWIG_arg_fail(1)) SWIG_fail;
29376 {
29377 PyThreadState* __tstate = wxPyBeginAllowThreads();
29378 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29379
29380 wxPyEndAllowThreads(__tstate);
29381 if (PyErr_Occurred()) SWIG_fail;
29382 }
29383 {
29384 resultobj = SWIG_From_int((int)(result));
29385 }
29386 return resultobj;
29387 fail:
29388 return NULL;
29389 }
29390
29391
29392 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29393 PyObject *resultobj;
29394 wxWindow *arg1 = (wxWindow *) 0 ;
29395 wxString *arg2 = 0 ;
29396 int *arg3 = (int *) 0 ;
29397 int *arg4 = (int *) 0 ;
29398 bool temp2 = false ;
29399 int temp3 ;
29400 int res3 = 0 ;
29401 int temp4 ;
29402 int res4 = 0 ;
29403 PyObject * obj0 = 0 ;
29404 PyObject * obj1 = 0 ;
29405 char *kwnames[] = {
29406 (char *) "self",(char *) "string", NULL
29407 };
29408
29409 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29410 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29413 if (SWIG_arg_fail(1)) SWIG_fail;
29414 {
29415 arg2 = wxString_in_helper(obj1);
29416 if (arg2 == NULL) SWIG_fail;
29417 temp2 = true;
29418 }
29419 {
29420 PyThreadState* __tstate = wxPyBeginAllowThreads();
29421 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29422
29423 wxPyEndAllowThreads(__tstate);
29424 if (PyErr_Occurred()) SWIG_fail;
29425 }
29426 Py_INCREF(Py_None); resultobj = Py_None;
29427 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29428 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29429 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29430 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29431 {
29432 if (temp2)
29433 delete arg2;
29434 }
29435 return resultobj;
29436 fail:
29437 {
29438 if (temp2)
29439 delete arg2;
29440 }
29441 return NULL;
29442 }
29443
29444
29445 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29446 PyObject *resultobj;
29447 wxWindow *arg1 = (wxWindow *) 0 ;
29448 wxString *arg2 = 0 ;
29449 int *arg3 = (int *) 0 ;
29450 int *arg4 = (int *) 0 ;
29451 int *arg5 = (int *) 0 ;
29452 int *arg6 = (int *) 0 ;
29453 wxFont *arg7 = (wxFont *) NULL ;
29454 bool temp2 = false ;
29455 int temp3 ;
29456 int res3 = 0 ;
29457 int temp4 ;
29458 int res4 = 0 ;
29459 int temp5 ;
29460 int res5 = 0 ;
29461 int temp6 ;
29462 int res6 = 0 ;
29463 PyObject * obj0 = 0 ;
29464 PyObject * obj1 = 0 ;
29465 PyObject * obj2 = 0 ;
29466 char *kwnames[] = {
29467 (char *) "self",(char *) "string",(char *) "font", NULL
29468 };
29469
29470 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29471 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29472 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29473 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = wxString_in_helper(obj1);
29479 if (arg2 == NULL) SWIG_fail;
29480 temp2 = true;
29481 }
29482 if (obj2) {
29483 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29484 if (SWIG_arg_fail(7)) SWIG_fail;
29485 }
29486 {
29487 PyThreadState* __tstate = wxPyBeginAllowThreads();
29488 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29489
29490 wxPyEndAllowThreads(__tstate);
29491 if (PyErr_Occurred()) SWIG_fail;
29492 }
29493 Py_INCREF(Py_None); resultobj = Py_None;
29494 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29495 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29496 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29497 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29498 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29499 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29500 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29501 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29502 {
29503 if (temp2)
29504 delete arg2;
29505 }
29506 return resultobj;
29507 fail:
29508 {
29509 if (temp2)
29510 delete arg2;
29511 }
29512 return NULL;
29513 }
29514
29515
29516 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29517 PyObject *resultobj;
29518 wxWindow *arg1 = (wxWindow *) 0 ;
29519 int *arg2 = (int *) 0 ;
29520 int *arg3 = (int *) 0 ;
29521 int temp2 ;
29522 int res2 = 0 ;
29523 int temp3 ;
29524 int res3 = 0 ;
29525 PyObject * obj0 = 0 ;
29526 PyObject * obj1 = 0 ;
29527 PyObject * obj2 = 0 ;
29528 char *kwnames[] = {
29529 (char *) "self",(char *) "x",(char *) "y", NULL
29530 };
29531
29532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29534 if (SWIG_arg_fail(1)) SWIG_fail;
29535 {
29536 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29537 temp2 = SWIG_As_int(obj1);
29538 if (SWIG_arg_fail(2)) SWIG_fail;
29539 arg2 = &temp2;
29540 res2 = SWIG_NEWOBJ;
29541 }
29542 }
29543 {
29544 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29545 temp3 = SWIG_As_int(obj2);
29546 if (SWIG_arg_fail(3)) SWIG_fail;
29547 arg3 = &temp3;
29548 res3 = SWIG_NEWOBJ;
29549 }
29550 }
29551 {
29552 PyThreadState* __tstate = wxPyBeginAllowThreads();
29553 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29554
29555 wxPyEndAllowThreads(__tstate);
29556 if (PyErr_Occurred()) SWIG_fail;
29557 }
29558 Py_INCREF(Py_None); resultobj = Py_None;
29559 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29560 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29561 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29562 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29563 return resultobj;
29564 fail:
29565 return NULL;
29566 }
29567
29568
29569 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29570 PyObject *resultobj;
29571 wxWindow *arg1 = (wxWindow *) 0 ;
29572 int *arg2 = (int *) 0 ;
29573 int *arg3 = (int *) 0 ;
29574 int temp2 ;
29575 int res2 = 0 ;
29576 int temp3 ;
29577 int res3 = 0 ;
29578 PyObject * obj0 = 0 ;
29579 PyObject * obj1 = 0 ;
29580 PyObject * obj2 = 0 ;
29581 char *kwnames[] = {
29582 (char *) "self",(char *) "x",(char *) "y", NULL
29583 };
29584
29585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29587 if (SWIG_arg_fail(1)) SWIG_fail;
29588 {
29589 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29590 temp2 = SWIG_As_int(obj1);
29591 if (SWIG_arg_fail(2)) SWIG_fail;
29592 arg2 = &temp2;
29593 res2 = SWIG_NEWOBJ;
29594 }
29595 }
29596 {
29597 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29598 temp3 = SWIG_As_int(obj2);
29599 if (SWIG_arg_fail(3)) SWIG_fail;
29600 arg3 = &temp3;
29601 res3 = SWIG_NEWOBJ;
29602 }
29603 }
29604 {
29605 PyThreadState* __tstate = wxPyBeginAllowThreads();
29606 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29607
29608 wxPyEndAllowThreads(__tstate);
29609 if (PyErr_Occurred()) SWIG_fail;
29610 }
29611 Py_INCREF(Py_None); resultobj = Py_None;
29612 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29613 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29614 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29615 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29616 return resultobj;
29617 fail:
29618 return NULL;
29619 }
29620
29621
29622 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29623 PyObject *resultobj;
29624 wxWindow *arg1 = (wxWindow *) 0 ;
29625 wxPoint *arg2 = 0 ;
29626 wxPoint result;
29627 wxPoint temp2 ;
29628 PyObject * obj0 = 0 ;
29629 PyObject * obj1 = 0 ;
29630 char *kwnames[] = {
29631 (char *) "self",(char *) "pt", NULL
29632 };
29633
29634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
29635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29636 if (SWIG_arg_fail(1)) SWIG_fail;
29637 {
29638 arg2 = &temp2;
29639 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29640 }
29641 {
29642 PyThreadState* __tstate = wxPyBeginAllowThreads();
29643 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
29644
29645 wxPyEndAllowThreads(__tstate);
29646 if (PyErr_Occurred()) SWIG_fail;
29647 }
29648 {
29649 wxPoint * resultptr;
29650 resultptr = new wxPoint((wxPoint &)(result));
29651 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29652 }
29653 return resultobj;
29654 fail:
29655 return NULL;
29656 }
29657
29658
29659 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
29660 PyObject *resultobj;
29661 wxWindow *arg1 = (wxWindow *) 0 ;
29662 wxPoint *arg2 = 0 ;
29663 wxPoint result;
29664 wxPoint temp2 ;
29665 PyObject * obj0 = 0 ;
29666 PyObject * obj1 = 0 ;
29667 char *kwnames[] = {
29668 (char *) "self",(char *) "pt", NULL
29669 };
29670
29671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
29672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29673 if (SWIG_arg_fail(1)) SWIG_fail;
29674 {
29675 arg2 = &temp2;
29676 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29677 }
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
29681
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 {
29686 wxPoint * resultptr;
29687 resultptr = new wxPoint((wxPoint &)(result));
29688 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29689 }
29690 return resultobj;
29691 fail:
29692 return NULL;
29693 }
29694
29695
29696 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
29697 PyObject *resultobj;
29698 wxWindow *arg1 = (wxWindow *) 0 ;
29699 int arg2 ;
29700 int arg3 ;
29701 wxHitTest result;
29702 PyObject * obj0 = 0 ;
29703 PyObject * obj1 = 0 ;
29704 PyObject * obj2 = 0 ;
29705 char *kwnames[] = {
29706 (char *) "self",(char *) "x",(char *) "y", NULL
29707 };
29708
29709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29711 if (SWIG_arg_fail(1)) SWIG_fail;
29712 {
29713 arg2 = (int)(SWIG_As_int(obj1));
29714 if (SWIG_arg_fail(2)) SWIG_fail;
29715 }
29716 {
29717 arg3 = (int)(SWIG_As_int(obj2));
29718 if (SWIG_arg_fail(3)) SWIG_fail;
29719 }
29720 {
29721 PyThreadState* __tstate = wxPyBeginAllowThreads();
29722 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
29723
29724 wxPyEndAllowThreads(__tstate);
29725 if (PyErr_Occurred()) SWIG_fail;
29726 }
29727 resultobj = SWIG_From_int((result));
29728 return resultobj;
29729 fail:
29730 return NULL;
29731 }
29732
29733
29734 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
29735 PyObject *resultobj;
29736 wxWindow *arg1 = (wxWindow *) 0 ;
29737 wxPoint *arg2 = 0 ;
29738 wxHitTest result;
29739 wxPoint temp2 ;
29740 PyObject * obj0 = 0 ;
29741 PyObject * obj1 = 0 ;
29742 char *kwnames[] = {
29743 (char *) "self",(char *) "pt", NULL
29744 };
29745
29746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
29747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29748 if (SWIG_arg_fail(1)) SWIG_fail;
29749 {
29750 arg2 = &temp2;
29751 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29752 }
29753 {
29754 PyThreadState* __tstate = wxPyBeginAllowThreads();
29755 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
29756
29757 wxPyEndAllowThreads(__tstate);
29758 if (PyErr_Occurred()) SWIG_fail;
29759 }
29760 resultobj = SWIG_From_int((result));
29761 return resultobj;
29762 fail:
29763 return NULL;
29764 }
29765
29766
29767 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
29768 PyObject *resultobj;
29769 wxWindow *arg1 = (wxWindow *) 0 ;
29770 long arg2 ;
29771 wxBorder result;
29772 PyObject * obj0 = 0 ;
29773 PyObject * obj1 = 0 ;
29774
29775 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
29776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29777 if (SWIG_arg_fail(1)) SWIG_fail;
29778 {
29779 arg2 = (long)(SWIG_As_long(obj1));
29780 if (SWIG_arg_fail(2)) SWIG_fail;
29781 }
29782 {
29783 PyThreadState* __tstate = wxPyBeginAllowThreads();
29784 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
29785
29786 wxPyEndAllowThreads(__tstate);
29787 if (PyErr_Occurred()) SWIG_fail;
29788 }
29789 resultobj = SWIG_From_int((result));
29790 return resultobj;
29791 fail:
29792 return NULL;
29793 }
29794
29795
29796 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
29797 PyObject *resultobj;
29798 wxWindow *arg1 = (wxWindow *) 0 ;
29799 wxBorder result;
29800 PyObject * obj0 = 0 ;
29801
29802 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
29803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29804 if (SWIG_arg_fail(1)) SWIG_fail;
29805 {
29806 PyThreadState* __tstate = wxPyBeginAllowThreads();
29807 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
29808
29809 wxPyEndAllowThreads(__tstate);
29810 if (PyErr_Occurred()) SWIG_fail;
29811 }
29812 resultobj = SWIG_From_int((result));
29813 return resultobj;
29814 fail:
29815 return NULL;
29816 }
29817
29818
29819 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
29820 int argc;
29821 PyObject *argv[3];
29822 int ii;
29823
29824 argc = PyObject_Length(args);
29825 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
29826 argv[ii] = PyTuple_GetItem(args,ii);
29827 }
29828 if (argc == 1) {
29829 int _v;
29830 {
29831 void *ptr;
29832 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29833 _v = 0;
29834 PyErr_Clear();
29835 } else {
29836 _v = 1;
29837 }
29838 }
29839 if (_v) {
29840 return _wrap_Window_GetBorder__SWIG_1(self,args);
29841 }
29842 }
29843 if (argc == 2) {
29844 int _v;
29845 {
29846 void *ptr;
29847 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
29848 _v = 0;
29849 PyErr_Clear();
29850 } else {
29851 _v = 1;
29852 }
29853 }
29854 if (_v) {
29855 _v = SWIG_Check_long(argv[1]);
29856 if (_v) {
29857 return _wrap_Window_GetBorder__SWIG_0(self,args);
29858 }
29859 }
29860 }
29861
29862 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
29863 return NULL;
29864 }
29865
29866
29867 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
29868 PyObject *resultobj;
29869 wxWindow *arg1 = (wxWindow *) 0 ;
29870 long arg2 = (long) wxUPDATE_UI_NONE ;
29871 PyObject * obj0 = 0 ;
29872 PyObject * obj1 = 0 ;
29873 char *kwnames[] = {
29874 (char *) "self",(char *) "flags", NULL
29875 };
29876
29877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
29878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29879 if (SWIG_arg_fail(1)) SWIG_fail;
29880 if (obj1) {
29881 {
29882 arg2 = (long)(SWIG_As_long(obj1));
29883 if (SWIG_arg_fail(2)) SWIG_fail;
29884 }
29885 }
29886 {
29887 PyThreadState* __tstate = wxPyBeginAllowThreads();
29888 (arg1)->UpdateWindowUI(arg2);
29889
29890 wxPyEndAllowThreads(__tstate);
29891 if (PyErr_Occurred()) SWIG_fail;
29892 }
29893 Py_INCREF(Py_None); resultobj = Py_None;
29894 return resultobj;
29895 fail:
29896 return NULL;
29897 }
29898
29899
29900 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
29901 PyObject *resultobj;
29902 wxWindow *arg1 = (wxWindow *) 0 ;
29903 wxMenu *arg2 = (wxMenu *) 0 ;
29904 int arg3 = (int) -1 ;
29905 int arg4 = (int) -1 ;
29906 bool result;
29907 PyObject * obj0 = 0 ;
29908 PyObject * obj1 = 0 ;
29909 PyObject * obj2 = 0 ;
29910 PyObject * obj3 = 0 ;
29911 char *kwnames[] = {
29912 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
29913 };
29914
29915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29917 if (SWIG_arg_fail(1)) SWIG_fail;
29918 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
29919 if (SWIG_arg_fail(2)) SWIG_fail;
29920 if (obj2) {
29921 {
29922 arg3 = (int)(SWIG_As_int(obj2));
29923 if (SWIG_arg_fail(3)) SWIG_fail;
29924 }
29925 }
29926 if (obj3) {
29927 {
29928 arg4 = (int)(SWIG_As_int(obj3));
29929 if (SWIG_arg_fail(4)) SWIG_fail;
29930 }
29931 }
29932 {
29933 PyThreadState* __tstate = wxPyBeginAllowThreads();
29934 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
29935
29936 wxPyEndAllowThreads(__tstate);
29937 if (PyErr_Occurred()) SWIG_fail;
29938 }
29939 {
29940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29941 }
29942 return resultobj;
29943 fail:
29944 return NULL;
29945 }
29946
29947
29948 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
29949 PyObject *resultobj;
29950 wxWindow *arg1 = (wxWindow *) 0 ;
29951 wxMenu *arg2 = (wxMenu *) 0 ;
29952 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29953 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29954 bool result;
29955 wxPoint temp3 ;
29956 PyObject * obj0 = 0 ;
29957 PyObject * obj1 = 0 ;
29958 PyObject * obj2 = 0 ;
29959 char *kwnames[] = {
29960 (char *) "self",(char *) "menu",(char *) "pos", NULL
29961 };
29962
29963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
29964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29965 if (SWIG_arg_fail(1)) SWIG_fail;
29966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
29967 if (SWIG_arg_fail(2)) SWIG_fail;
29968 if (obj2) {
29969 {
29970 arg3 = &temp3;
29971 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29972 }
29973 }
29974 {
29975 PyThreadState* __tstate = wxPyBeginAllowThreads();
29976 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
29977
29978 wxPyEndAllowThreads(__tstate);
29979 if (PyErr_Occurred()) SWIG_fail;
29980 }
29981 {
29982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29983 }
29984 return resultobj;
29985 fail:
29986 return NULL;
29987 }
29988
29989
29990 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
29991 PyObject *resultobj;
29992 wxWindow *arg1 = (wxWindow *) 0 ;
29993 long result;
29994 PyObject * obj0 = 0 ;
29995 char *kwnames[] = {
29996 (char *) "self", NULL
29997 };
29998
29999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30001 if (SWIG_arg_fail(1)) SWIG_fail;
30002 {
30003 PyThreadState* __tstate = wxPyBeginAllowThreads();
30004 result = (long)wxWindow_GetHandle(arg1);
30005
30006 wxPyEndAllowThreads(__tstate);
30007 if (PyErr_Occurred()) SWIG_fail;
30008 }
30009 {
30010 resultobj = SWIG_From_long((long)(result));
30011 }
30012 return resultobj;
30013 fail:
30014 return NULL;
30015 }
30016
30017
30018 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30019 PyObject *resultobj;
30020 wxWindow *arg1 = (wxWindow *) 0 ;
30021 long arg2 ;
30022 PyObject * obj0 = 0 ;
30023 PyObject * obj1 = 0 ;
30024 char *kwnames[] = {
30025 (char *) "self",(char *) "handle", NULL
30026 };
30027
30028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30030 if (SWIG_arg_fail(1)) SWIG_fail;
30031 {
30032 arg2 = (long)(SWIG_As_long(obj1));
30033 if (SWIG_arg_fail(2)) SWIG_fail;
30034 }
30035 {
30036 PyThreadState* __tstate = wxPyBeginAllowThreads();
30037 wxWindow_AssociateHandle(arg1,arg2);
30038
30039 wxPyEndAllowThreads(__tstate);
30040 if (PyErr_Occurred()) SWIG_fail;
30041 }
30042 Py_INCREF(Py_None); resultobj = Py_None;
30043 return resultobj;
30044 fail:
30045 return NULL;
30046 }
30047
30048
30049 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30050 PyObject *resultobj;
30051 wxWindow *arg1 = (wxWindow *) 0 ;
30052 PyObject * obj0 = 0 ;
30053 char *kwnames[] = {
30054 (char *) "self", NULL
30055 };
30056
30057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30059 if (SWIG_arg_fail(1)) SWIG_fail;
30060 {
30061 PyThreadState* __tstate = wxPyBeginAllowThreads();
30062 (arg1)->DissociateHandle();
30063
30064 wxPyEndAllowThreads(__tstate);
30065 if (PyErr_Occurred()) SWIG_fail;
30066 }
30067 Py_INCREF(Py_None); resultobj = Py_None;
30068 return resultobj;
30069 fail:
30070 return NULL;
30071 }
30072
30073
30074 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30075 PyObject *resultobj;
30076 wxWindow *arg1 = (wxWindow *) 0 ;
30077 int arg2 ;
30078 bool result;
30079 PyObject * obj0 = 0 ;
30080 PyObject * obj1 = 0 ;
30081 char *kwnames[] = {
30082 (char *) "self",(char *) "orient", NULL
30083 };
30084
30085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30087 if (SWIG_arg_fail(1)) SWIG_fail;
30088 {
30089 arg2 = (int)(SWIG_As_int(obj1));
30090 if (SWIG_arg_fail(2)) SWIG_fail;
30091 }
30092 {
30093 PyThreadState* __tstate = wxPyBeginAllowThreads();
30094 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30095
30096 wxPyEndAllowThreads(__tstate);
30097 if (PyErr_Occurred()) SWIG_fail;
30098 }
30099 {
30100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30101 }
30102 return resultobj;
30103 fail:
30104 return NULL;
30105 }
30106
30107
30108 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30109 PyObject *resultobj;
30110 wxWindow *arg1 = (wxWindow *) 0 ;
30111 int arg2 ;
30112 int arg3 ;
30113 int arg4 ;
30114 int arg5 ;
30115 bool arg6 = (bool) true ;
30116 PyObject * obj0 = 0 ;
30117 PyObject * obj1 = 0 ;
30118 PyObject * obj2 = 0 ;
30119 PyObject * obj3 = 0 ;
30120 PyObject * obj4 = 0 ;
30121 PyObject * obj5 = 0 ;
30122 char *kwnames[] = {
30123 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30124 };
30125
30126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30128 if (SWIG_arg_fail(1)) SWIG_fail;
30129 {
30130 arg2 = (int)(SWIG_As_int(obj1));
30131 if (SWIG_arg_fail(2)) SWIG_fail;
30132 }
30133 {
30134 arg3 = (int)(SWIG_As_int(obj2));
30135 if (SWIG_arg_fail(3)) SWIG_fail;
30136 }
30137 {
30138 arg4 = (int)(SWIG_As_int(obj3));
30139 if (SWIG_arg_fail(4)) SWIG_fail;
30140 }
30141 {
30142 arg5 = (int)(SWIG_As_int(obj4));
30143 if (SWIG_arg_fail(5)) SWIG_fail;
30144 }
30145 if (obj5) {
30146 {
30147 arg6 = (bool)(SWIG_As_bool(obj5));
30148 if (SWIG_arg_fail(6)) SWIG_fail;
30149 }
30150 }
30151 {
30152 PyThreadState* __tstate = wxPyBeginAllowThreads();
30153 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30154
30155 wxPyEndAllowThreads(__tstate);
30156 if (PyErr_Occurred()) SWIG_fail;
30157 }
30158 Py_INCREF(Py_None); resultobj = Py_None;
30159 return resultobj;
30160 fail:
30161 return NULL;
30162 }
30163
30164
30165 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30166 PyObject *resultobj;
30167 wxWindow *arg1 = (wxWindow *) 0 ;
30168 int arg2 ;
30169 int arg3 ;
30170 bool arg4 = (bool) true ;
30171 PyObject * obj0 = 0 ;
30172 PyObject * obj1 = 0 ;
30173 PyObject * obj2 = 0 ;
30174 PyObject * obj3 = 0 ;
30175 char *kwnames[] = {
30176 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30177 };
30178
30179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30181 if (SWIG_arg_fail(1)) SWIG_fail;
30182 {
30183 arg2 = (int)(SWIG_As_int(obj1));
30184 if (SWIG_arg_fail(2)) SWIG_fail;
30185 }
30186 {
30187 arg3 = (int)(SWIG_As_int(obj2));
30188 if (SWIG_arg_fail(3)) SWIG_fail;
30189 }
30190 if (obj3) {
30191 {
30192 arg4 = (bool)(SWIG_As_bool(obj3));
30193 if (SWIG_arg_fail(4)) SWIG_fail;
30194 }
30195 }
30196 {
30197 PyThreadState* __tstate = wxPyBeginAllowThreads();
30198 (arg1)->SetScrollPos(arg2,arg3,arg4);
30199
30200 wxPyEndAllowThreads(__tstate);
30201 if (PyErr_Occurred()) SWIG_fail;
30202 }
30203 Py_INCREF(Py_None); resultobj = Py_None;
30204 return resultobj;
30205 fail:
30206 return NULL;
30207 }
30208
30209
30210 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30211 PyObject *resultobj;
30212 wxWindow *arg1 = (wxWindow *) 0 ;
30213 int arg2 ;
30214 int result;
30215 PyObject * obj0 = 0 ;
30216 PyObject * obj1 = 0 ;
30217 char *kwnames[] = {
30218 (char *) "self",(char *) "orientation", NULL
30219 };
30220
30221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30223 if (SWIG_arg_fail(1)) SWIG_fail;
30224 {
30225 arg2 = (int)(SWIG_As_int(obj1));
30226 if (SWIG_arg_fail(2)) SWIG_fail;
30227 }
30228 {
30229 PyThreadState* __tstate = wxPyBeginAllowThreads();
30230 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30231
30232 wxPyEndAllowThreads(__tstate);
30233 if (PyErr_Occurred()) SWIG_fail;
30234 }
30235 {
30236 resultobj = SWIG_From_int((int)(result));
30237 }
30238 return resultobj;
30239 fail:
30240 return NULL;
30241 }
30242
30243
30244 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30245 PyObject *resultobj;
30246 wxWindow *arg1 = (wxWindow *) 0 ;
30247 int arg2 ;
30248 int result;
30249 PyObject * obj0 = 0 ;
30250 PyObject * obj1 = 0 ;
30251 char *kwnames[] = {
30252 (char *) "self",(char *) "orientation", NULL
30253 };
30254
30255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30257 if (SWIG_arg_fail(1)) SWIG_fail;
30258 {
30259 arg2 = (int)(SWIG_As_int(obj1));
30260 if (SWIG_arg_fail(2)) SWIG_fail;
30261 }
30262 {
30263 PyThreadState* __tstate = wxPyBeginAllowThreads();
30264 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30265
30266 wxPyEndAllowThreads(__tstate);
30267 if (PyErr_Occurred()) SWIG_fail;
30268 }
30269 {
30270 resultobj = SWIG_From_int((int)(result));
30271 }
30272 return resultobj;
30273 fail:
30274 return NULL;
30275 }
30276
30277
30278 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30279 PyObject *resultobj;
30280 wxWindow *arg1 = (wxWindow *) 0 ;
30281 int arg2 ;
30282 int result;
30283 PyObject * obj0 = 0 ;
30284 PyObject * obj1 = 0 ;
30285 char *kwnames[] = {
30286 (char *) "self",(char *) "orientation", NULL
30287 };
30288
30289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30291 if (SWIG_arg_fail(1)) SWIG_fail;
30292 {
30293 arg2 = (int)(SWIG_As_int(obj1));
30294 if (SWIG_arg_fail(2)) SWIG_fail;
30295 }
30296 {
30297 PyThreadState* __tstate = wxPyBeginAllowThreads();
30298 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30299
30300 wxPyEndAllowThreads(__tstate);
30301 if (PyErr_Occurred()) SWIG_fail;
30302 }
30303 {
30304 resultobj = SWIG_From_int((int)(result));
30305 }
30306 return resultobj;
30307 fail:
30308 return NULL;
30309 }
30310
30311
30312 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30313 PyObject *resultobj;
30314 wxWindow *arg1 = (wxWindow *) 0 ;
30315 int arg2 ;
30316 int arg3 ;
30317 wxRect *arg4 = (wxRect *) NULL ;
30318 PyObject * obj0 = 0 ;
30319 PyObject * obj1 = 0 ;
30320 PyObject * obj2 = 0 ;
30321 PyObject * obj3 = 0 ;
30322 char *kwnames[] = {
30323 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30324 };
30325
30326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30328 if (SWIG_arg_fail(1)) SWIG_fail;
30329 {
30330 arg2 = (int)(SWIG_As_int(obj1));
30331 if (SWIG_arg_fail(2)) SWIG_fail;
30332 }
30333 {
30334 arg3 = (int)(SWIG_As_int(obj2));
30335 if (SWIG_arg_fail(3)) SWIG_fail;
30336 }
30337 if (obj3) {
30338 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30339 if (SWIG_arg_fail(4)) SWIG_fail;
30340 }
30341 {
30342 PyThreadState* __tstate = wxPyBeginAllowThreads();
30343 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30344
30345 wxPyEndAllowThreads(__tstate);
30346 if (PyErr_Occurred()) SWIG_fail;
30347 }
30348 Py_INCREF(Py_None); resultobj = Py_None;
30349 return resultobj;
30350 fail:
30351 return NULL;
30352 }
30353
30354
30355 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30356 PyObject *resultobj;
30357 wxWindow *arg1 = (wxWindow *) 0 ;
30358 int arg2 ;
30359 bool result;
30360 PyObject * obj0 = 0 ;
30361 PyObject * obj1 = 0 ;
30362 char *kwnames[] = {
30363 (char *) "self",(char *) "lines", NULL
30364 };
30365
30366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30368 if (SWIG_arg_fail(1)) SWIG_fail;
30369 {
30370 arg2 = (int)(SWIG_As_int(obj1));
30371 if (SWIG_arg_fail(2)) SWIG_fail;
30372 }
30373 {
30374 PyThreadState* __tstate = wxPyBeginAllowThreads();
30375 result = (bool)(arg1)->ScrollLines(arg2);
30376
30377 wxPyEndAllowThreads(__tstate);
30378 if (PyErr_Occurred()) SWIG_fail;
30379 }
30380 {
30381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30382 }
30383 return resultobj;
30384 fail:
30385 return NULL;
30386 }
30387
30388
30389 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30390 PyObject *resultobj;
30391 wxWindow *arg1 = (wxWindow *) 0 ;
30392 int arg2 ;
30393 bool result;
30394 PyObject * obj0 = 0 ;
30395 PyObject * obj1 = 0 ;
30396 char *kwnames[] = {
30397 (char *) "self",(char *) "pages", NULL
30398 };
30399
30400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30402 if (SWIG_arg_fail(1)) SWIG_fail;
30403 {
30404 arg2 = (int)(SWIG_As_int(obj1));
30405 if (SWIG_arg_fail(2)) SWIG_fail;
30406 }
30407 {
30408 PyThreadState* __tstate = wxPyBeginAllowThreads();
30409 result = (bool)(arg1)->ScrollPages(arg2);
30410
30411 wxPyEndAllowThreads(__tstate);
30412 if (PyErr_Occurred()) SWIG_fail;
30413 }
30414 {
30415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30416 }
30417 return resultobj;
30418 fail:
30419 return NULL;
30420 }
30421
30422
30423 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30424 PyObject *resultobj;
30425 wxWindow *arg1 = (wxWindow *) 0 ;
30426 bool result;
30427 PyObject * obj0 = 0 ;
30428 char *kwnames[] = {
30429 (char *) "self", NULL
30430 };
30431
30432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30434 if (SWIG_arg_fail(1)) SWIG_fail;
30435 {
30436 PyThreadState* __tstate = wxPyBeginAllowThreads();
30437 result = (bool)(arg1)->LineUp();
30438
30439 wxPyEndAllowThreads(__tstate);
30440 if (PyErr_Occurred()) SWIG_fail;
30441 }
30442 {
30443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30444 }
30445 return resultobj;
30446 fail:
30447 return NULL;
30448 }
30449
30450
30451 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30452 PyObject *resultobj;
30453 wxWindow *arg1 = (wxWindow *) 0 ;
30454 bool result;
30455 PyObject * obj0 = 0 ;
30456 char *kwnames[] = {
30457 (char *) "self", NULL
30458 };
30459
30460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30462 if (SWIG_arg_fail(1)) SWIG_fail;
30463 {
30464 PyThreadState* __tstate = wxPyBeginAllowThreads();
30465 result = (bool)(arg1)->LineDown();
30466
30467 wxPyEndAllowThreads(__tstate);
30468 if (PyErr_Occurred()) SWIG_fail;
30469 }
30470 {
30471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30472 }
30473 return resultobj;
30474 fail:
30475 return NULL;
30476 }
30477
30478
30479 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30480 PyObject *resultobj;
30481 wxWindow *arg1 = (wxWindow *) 0 ;
30482 bool result;
30483 PyObject * obj0 = 0 ;
30484 char *kwnames[] = {
30485 (char *) "self", NULL
30486 };
30487
30488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30490 if (SWIG_arg_fail(1)) SWIG_fail;
30491 {
30492 PyThreadState* __tstate = wxPyBeginAllowThreads();
30493 result = (bool)(arg1)->PageUp();
30494
30495 wxPyEndAllowThreads(__tstate);
30496 if (PyErr_Occurred()) SWIG_fail;
30497 }
30498 {
30499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30500 }
30501 return resultobj;
30502 fail:
30503 return NULL;
30504 }
30505
30506
30507 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30508 PyObject *resultobj;
30509 wxWindow *arg1 = (wxWindow *) 0 ;
30510 bool result;
30511 PyObject * obj0 = 0 ;
30512 char *kwnames[] = {
30513 (char *) "self", NULL
30514 };
30515
30516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30518 if (SWIG_arg_fail(1)) SWIG_fail;
30519 {
30520 PyThreadState* __tstate = wxPyBeginAllowThreads();
30521 result = (bool)(arg1)->PageDown();
30522
30523 wxPyEndAllowThreads(__tstate);
30524 if (PyErr_Occurred()) SWIG_fail;
30525 }
30526 {
30527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30528 }
30529 return resultobj;
30530 fail:
30531 return NULL;
30532 }
30533
30534
30535 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30536 PyObject *resultobj;
30537 wxWindow *arg1 = (wxWindow *) 0 ;
30538 wxString *arg2 = 0 ;
30539 bool temp2 = false ;
30540 PyObject * obj0 = 0 ;
30541 PyObject * obj1 = 0 ;
30542 char *kwnames[] = {
30543 (char *) "self",(char *) "text", NULL
30544 };
30545
30546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30548 if (SWIG_arg_fail(1)) SWIG_fail;
30549 {
30550 arg2 = wxString_in_helper(obj1);
30551 if (arg2 == NULL) SWIG_fail;
30552 temp2 = true;
30553 }
30554 {
30555 PyThreadState* __tstate = wxPyBeginAllowThreads();
30556 (arg1)->SetHelpText((wxString const &)*arg2);
30557
30558 wxPyEndAllowThreads(__tstate);
30559 if (PyErr_Occurred()) SWIG_fail;
30560 }
30561 Py_INCREF(Py_None); resultobj = Py_None;
30562 {
30563 if (temp2)
30564 delete arg2;
30565 }
30566 return resultobj;
30567 fail:
30568 {
30569 if (temp2)
30570 delete arg2;
30571 }
30572 return NULL;
30573 }
30574
30575
30576 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30577 PyObject *resultobj;
30578 wxWindow *arg1 = (wxWindow *) 0 ;
30579 wxString *arg2 = 0 ;
30580 bool temp2 = false ;
30581 PyObject * obj0 = 0 ;
30582 PyObject * obj1 = 0 ;
30583 char *kwnames[] = {
30584 (char *) "self",(char *) "text", NULL
30585 };
30586
30587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30589 if (SWIG_arg_fail(1)) SWIG_fail;
30590 {
30591 arg2 = wxString_in_helper(obj1);
30592 if (arg2 == NULL) SWIG_fail;
30593 temp2 = true;
30594 }
30595 {
30596 PyThreadState* __tstate = wxPyBeginAllowThreads();
30597 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30598
30599 wxPyEndAllowThreads(__tstate);
30600 if (PyErr_Occurred()) SWIG_fail;
30601 }
30602 Py_INCREF(Py_None); resultobj = Py_None;
30603 {
30604 if (temp2)
30605 delete arg2;
30606 }
30607 return resultobj;
30608 fail:
30609 {
30610 if (temp2)
30611 delete arg2;
30612 }
30613 return NULL;
30614 }
30615
30616
30617 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30618 PyObject *resultobj;
30619 wxWindow *arg1 = (wxWindow *) 0 ;
30620 wxString result;
30621 PyObject * obj0 = 0 ;
30622 char *kwnames[] = {
30623 (char *) "self", NULL
30624 };
30625
30626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
30627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30628 if (SWIG_arg_fail(1)) SWIG_fail;
30629 {
30630 PyThreadState* __tstate = wxPyBeginAllowThreads();
30631 result = ((wxWindow const *)arg1)->GetHelpText();
30632
30633 wxPyEndAllowThreads(__tstate);
30634 if (PyErr_Occurred()) SWIG_fail;
30635 }
30636 {
30637 #if wxUSE_UNICODE
30638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30639 #else
30640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30641 #endif
30642 }
30643 return resultobj;
30644 fail:
30645 return NULL;
30646 }
30647
30648
30649 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
30650 PyObject *resultobj;
30651 wxWindow *arg1 = (wxWindow *) 0 ;
30652 wxString *arg2 = 0 ;
30653 bool temp2 = false ;
30654 PyObject * obj0 = 0 ;
30655 PyObject * obj1 = 0 ;
30656 char *kwnames[] = {
30657 (char *) "self",(char *) "tip", NULL
30658 };
30659
30660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
30661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30662 if (SWIG_arg_fail(1)) SWIG_fail;
30663 {
30664 arg2 = wxString_in_helper(obj1);
30665 if (arg2 == NULL) SWIG_fail;
30666 temp2 = true;
30667 }
30668 {
30669 PyThreadState* __tstate = wxPyBeginAllowThreads();
30670 (arg1)->SetToolTip((wxString const &)*arg2);
30671
30672 wxPyEndAllowThreads(__tstate);
30673 if (PyErr_Occurred()) SWIG_fail;
30674 }
30675 Py_INCREF(Py_None); resultobj = Py_None;
30676 {
30677 if (temp2)
30678 delete arg2;
30679 }
30680 return resultobj;
30681 fail:
30682 {
30683 if (temp2)
30684 delete arg2;
30685 }
30686 return NULL;
30687 }
30688
30689
30690 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30691 PyObject *resultobj;
30692 wxWindow *arg1 = (wxWindow *) 0 ;
30693 wxToolTip *arg2 = (wxToolTip *) 0 ;
30694 PyObject * obj0 = 0 ;
30695 PyObject * obj1 = 0 ;
30696 char *kwnames[] = {
30697 (char *) "self",(char *) "tip", NULL
30698 };
30699
30700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
30701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30702 if (SWIG_arg_fail(1)) SWIG_fail;
30703 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
30704 if (SWIG_arg_fail(2)) SWIG_fail;
30705 {
30706 PyThreadState* __tstate = wxPyBeginAllowThreads();
30707 (arg1)->SetToolTip(arg2);
30708
30709 wxPyEndAllowThreads(__tstate);
30710 if (PyErr_Occurred()) SWIG_fail;
30711 }
30712 Py_INCREF(Py_None); resultobj = Py_None;
30713 return resultobj;
30714 fail:
30715 return NULL;
30716 }
30717
30718
30719 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30720 PyObject *resultobj;
30721 wxWindow *arg1 = (wxWindow *) 0 ;
30722 wxToolTip *result;
30723 PyObject * obj0 = 0 ;
30724 char *kwnames[] = {
30725 (char *) "self", NULL
30726 };
30727
30728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
30729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30730 if (SWIG_arg_fail(1)) SWIG_fail;
30731 {
30732 PyThreadState* __tstate = wxPyBeginAllowThreads();
30733 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
30734
30735 wxPyEndAllowThreads(__tstate);
30736 if (PyErr_Occurred()) SWIG_fail;
30737 }
30738 {
30739 resultobj = wxPyMake_wxObject(result, 0);
30740 }
30741 return resultobj;
30742 fail:
30743 return NULL;
30744 }
30745
30746
30747 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30748 PyObject *resultobj;
30749 wxWindow *arg1 = (wxWindow *) 0 ;
30750 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
30751 PyObject * obj0 = 0 ;
30752 PyObject * obj1 = 0 ;
30753 char *kwnames[] = {
30754 (char *) "self",(char *) "dropTarget", NULL
30755 };
30756
30757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
30758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30759 if (SWIG_arg_fail(1)) SWIG_fail;
30760 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
30761 if (SWIG_arg_fail(2)) SWIG_fail;
30762 {
30763 PyThreadState* __tstate = wxPyBeginAllowThreads();
30764 (arg1)->SetDropTarget(arg2);
30765
30766 wxPyEndAllowThreads(__tstate);
30767 if (PyErr_Occurred()) SWIG_fail;
30768 }
30769 Py_INCREF(Py_None); resultobj = Py_None;
30770 return resultobj;
30771 fail:
30772 return NULL;
30773 }
30774
30775
30776 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
30777 PyObject *resultobj;
30778 wxWindow *arg1 = (wxWindow *) 0 ;
30779 wxPyDropTarget *result;
30780 PyObject * obj0 = 0 ;
30781 char *kwnames[] = {
30782 (char *) "self", NULL
30783 };
30784
30785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
30786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30787 if (SWIG_arg_fail(1)) SWIG_fail;
30788 {
30789 PyThreadState* __tstate = wxPyBeginAllowThreads();
30790 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
30791
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
30796 return resultobj;
30797 fail:
30798 return NULL;
30799 }
30800
30801
30802 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30803 PyObject *resultobj;
30804 wxWindow *arg1 = (wxWindow *) 0 ;
30805 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
30806 PyObject * obj0 = 0 ;
30807 PyObject * obj1 = 0 ;
30808 char *kwnames[] = {
30809 (char *) "self",(char *) "constraints", NULL
30810 };
30811
30812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
30813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30814 if (SWIG_arg_fail(1)) SWIG_fail;
30815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
30816 if (SWIG_arg_fail(2)) SWIG_fail;
30817 {
30818 PyThreadState* __tstate = wxPyBeginAllowThreads();
30819 (arg1)->SetConstraints(arg2);
30820
30821 wxPyEndAllowThreads(__tstate);
30822 if (PyErr_Occurred()) SWIG_fail;
30823 }
30824 Py_INCREF(Py_None); resultobj = Py_None;
30825 return resultobj;
30826 fail:
30827 return NULL;
30828 }
30829
30830
30831 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
30832 PyObject *resultobj;
30833 wxWindow *arg1 = (wxWindow *) 0 ;
30834 wxLayoutConstraints *result;
30835 PyObject * obj0 = 0 ;
30836 char *kwnames[] = {
30837 (char *) "self", NULL
30838 };
30839
30840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
30841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30842 if (SWIG_arg_fail(1)) SWIG_fail;
30843 {
30844 PyThreadState* __tstate = wxPyBeginAllowThreads();
30845 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
30846
30847 wxPyEndAllowThreads(__tstate);
30848 if (PyErr_Occurred()) SWIG_fail;
30849 }
30850 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
30851 return resultobj;
30852 fail:
30853 return NULL;
30854 }
30855
30856
30857 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30858 PyObject *resultobj;
30859 wxWindow *arg1 = (wxWindow *) 0 ;
30860 bool arg2 ;
30861 PyObject * obj0 = 0 ;
30862 PyObject * obj1 = 0 ;
30863 char *kwnames[] = {
30864 (char *) "self",(char *) "autoLayout", NULL
30865 };
30866
30867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
30868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30869 if (SWIG_arg_fail(1)) SWIG_fail;
30870 {
30871 arg2 = (bool)(SWIG_As_bool(obj1));
30872 if (SWIG_arg_fail(2)) SWIG_fail;
30873 }
30874 {
30875 PyThreadState* __tstate = wxPyBeginAllowThreads();
30876 (arg1)->SetAutoLayout(arg2);
30877
30878 wxPyEndAllowThreads(__tstate);
30879 if (PyErr_Occurred()) SWIG_fail;
30880 }
30881 Py_INCREF(Py_None); resultobj = Py_None;
30882 return resultobj;
30883 fail:
30884 return NULL;
30885 }
30886
30887
30888 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
30889 PyObject *resultobj;
30890 wxWindow *arg1 = (wxWindow *) 0 ;
30891 bool result;
30892 PyObject * obj0 = 0 ;
30893 char *kwnames[] = {
30894 (char *) "self", NULL
30895 };
30896
30897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
30898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30899 if (SWIG_arg_fail(1)) SWIG_fail;
30900 {
30901 PyThreadState* __tstate = wxPyBeginAllowThreads();
30902 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
30903
30904 wxPyEndAllowThreads(__tstate);
30905 if (PyErr_Occurred()) SWIG_fail;
30906 }
30907 {
30908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30909 }
30910 return resultobj;
30911 fail:
30912 return NULL;
30913 }
30914
30915
30916 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
30917 PyObject *resultobj;
30918 wxWindow *arg1 = (wxWindow *) 0 ;
30919 bool result;
30920 PyObject * obj0 = 0 ;
30921 char *kwnames[] = {
30922 (char *) "self", NULL
30923 };
30924
30925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
30926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30927 if (SWIG_arg_fail(1)) SWIG_fail;
30928 {
30929 PyThreadState* __tstate = wxPyBeginAllowThreads();
30930 result = (bool)(arg1)->Layout();
30931
30932 wxPyEndAllowThreads(__tstate);
30933 if (PyErr_Occurred()) SWIG_fail;
30934 }
30935 {
30936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30937 }
30938 return resultobj;
30939 fail:
30940 return NULL;
30941 }
30942
30943
30944 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
30945 PyObject *resultobj;
30946 wxWindow *arg1 = (wxWindow *) 0 ;
30947 wxSizer *arg2 = (wxSizer *) 0 ;
30948 bool arg3 = (bool) true ;
30949 PyObject * obj0 = 0 ;
30950 PyObject * obj1 = 0 ;
30951 PyObject * obj2 = 0 ;
30952 char *kwnames[] = {
30953 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
30954 };
30955
30956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
30957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30958 if (SWIG_arg_fail(1)) SWIG_fail;
30959 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
30960 if (SWIG_arg_fail(2)) SWIG_fail;
30961 if (obj2) {
30962 {
30963 arg3 = (bool)(SWIG_As_bool(obj2));
30964 if (SWIG_arg_fail(3)) SWIG_fail;
30965 }
30966 }
30967 {
30968 PyThreadState* __tstate = wxPyBeginAllowThreads();
30969 (arg1)->SetSizer(arg2,arg3);
30970
30971 wxPyEndAllowThreads(__tstate);
30972 if (PyErr_Occurred()) SWIG_fail;
30973 }
30974 Py_INCREF(Py_None); resultobj = Py_None;
30975 return resultobj;
30976 fail:
30977 return NULL;
30978 }
30979
30980
30981 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
30982 PyObject *resultobj;
30983 wxWindow *arg1 = (wxWindow *) 0 ;
30984 wxSizer *arg2 = (wxSizer *) 0 ;
30985 bool arg3 = (bool) true ;
30986 PyObject * obj0 = 0 ;
30987 PyObject * obj1 = 0 ;
30988 PyObject * obj2 = 0 ;
30989 char *kwnames[] = {
30990 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
30991 };
30992
30993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
30994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30995 if (SWIG_arg_fail(1)) SWIG_fail;
30996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
30997 if (SWIG_arg_fail(2)) SWIG_fail;
30998 if (obj2) {
30999 {
31000 arg3 = (bool)(SWIG_As_bool(obj2));
31001 if (SWIG_arg_fail(3)) SWIG_fail;
31002 }
31003 }
31004 {
31005 PyThreadState* __tstate = wxPyBeginAllowThreads();
31006 (arg1)->SetSizerAndFit(arg2,arg3);
31007
31008 wxPyEndAllowThreads(__tstate);
31009 if (PyErr_Occurred()) SWIG_fail;
31010 }
31011 Py_INCREF(Py_None); resultobj = Py_None;
31012 return resultobj;
31013 fail:
31014 return NULL;
31015 }
31016
31017
31018 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31019 PyObject *resultobj;
31020 wxWindow *arg1 = (wxWindow *) 0 ;
31021 wxSizer *result;
31022 PyObject * obj0 = 0 ;
31023 char *kwnames[] = {
31024 (char *) "self", NULL
31025 };
31026
31027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31029 if (SWIG_arg_fail(1)) SWIG_fail;
31030 {
31031 PyThreadState* __tstate = wxPyBeginAllowThreads();
31032 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31033
31034 wxPyEndAllowThreads(__tstate);
31035 if (PyErr_Occurred()) SWIG_fail;
31036 }
31037 {
31038 resultobj = wxPyMake_wxSizer(result, 0);
31039 }
31040 return resultobj;
31041 fail:
31042 return NULL;
31043 }
31044
31045
31046 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31047 PyObject *resultobj;
31048 wxWindow *arg1 = (wxWindow *) 0 ;
31049 wxSizer *arg2 = (wxSizer *) 0 ;
31050 PyObject * obj0 = 0 ;
31051 PyObject * obj1 = 0 ;
31052 char *kwnames[] = {
31053 (char *) "self",(char *) "sizer", NULL
31054 };
31055
31056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31058 if (SWIG_arg_fail(1)) SWIG_fail;
31059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31060 if (SWIG_arg_fail(2)) SWIG_fail;
31061 {
31062 PyThreadState* __tstate = wxPyBeginAllowThreads();
31063 (arg1)->SetContainingSizer(arg2);
31064
31065 wxPyEndAllowThreads(__tstate);
31066 if (PyErr_Occurred()) SWIG_fail;
31067 }
31068 Py_INCREF(Py_None); resultobj = Py_None;
31069 return resultobj;
31070 fail:
31071 return NULL;
31072 }
31073
31074
31075 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31076 PyObject *resultobj;
31077 wxWindow *arg1 = (wxWindow *) 0 ;
31078 wxSizer *result;
31079 PyObject * obj0 = 0 ;
31080 char *kwnames[] = {
31081 (char *) "self", NULL
31082 };
31083
31084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31086 if (SWIG_arg_fail(1)) SWIG_fail;
31087 {
31088 PyThreadState* __tstate = wxPyBeginAllowThreads();
31089 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31090
31091 wxPyEndAllowThreads(__tstate);
31092 if (PyErr_Occurred()) SWIG_fail;
31093 }
31094 {
31095 resultobj = wxPyMake_wxSizer(result, 0);
31096 }
31097 return resultobj;
31098 fail:
31099 return NULL;
31100 }
31101
31102
31103 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31104 PyObject *resultobj;
31105 wxWindow *arg1 = (wxWindow *) 0 ;
31106 PyObject * obj0 = 0 ;
31107 char *kwnames[] = {
31108 (char *) "self", NULL
31109 };
31110
31111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31113 if (SWIG_arg_fail(1)) SWIG_fail;
31114 {
31115 PyThreadState* __tstate = wxPyBeginAllowThreads();
31116 (arg1)->InheritAttributes();
31117
31118 wxPyEndAllowThreads(__tstate);
31119 if (PyErr_Occurred()) SWIG_fail;
31120 }
31121 Py_INCREF(Py_None); resultobj = Py_None;
31122 return resultobj;
31123 fail:
31124 return NULL;
31125 }
31126
31127
31128 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31129 PyObject *resultobj;
31130 wxWindow *arg1 = (wxWindow *) 0 ;
31131 bool result;
31132 PyObject * obj0 = 0 ;
31133 char *kwnames[] = {
31134 (char *) "self", NULL
31135 };
31136
31137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31139 if (SWIG_arg_fail(1)) SWIG_fail;
31140 {
31141 PyThreadState* __tstate = wxPyBeginAllowThreads();
31142 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31143
31144 wxPyEndAllowThreads(__tstate);
31145 if (PyErr_Occurred()) SWIG_fail;
31146 }
31147 {
31148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31149 }
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31157 PyObject *obj;
31158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31159 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31160 Py_INCREF(obj);
31161 return Py_BuildValue((char *)"");
31162 }
31163 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31164 PyObject *resultobj;
31165 long arg1 ;
31166 wxWindow *arg2 = (wxWindow *) NULL ;
31167 wxWindow *result;
31168 PyObject * obj0 = 0 ;
31169 PyObject * obj1 = 0 ;
31170 char *kwnames[] = {
31171 (char *) "id",(char *) "parent", NULL
31172 };
31173
31174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31175 {
31176 arg1 = (long)(SWIG_As_long(obj0));
31177 if (SWIG_arg_fail(1)) SWIG_fail;
31178 }
31179 if (obj1) {
31180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31181 if (SWIG_arg_fail(2)) SWIG_fail;
31182 }
31183 {
31184 if (!wxPyCheckForApp()) SWIG_fail;
31185 PyThreadState* __tstate = wxPyBeginAllowThreads();
31186 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31187
31188 wxPyEndAllowThreads(__tstate);
31189 if (PyErr_Occurred()) SWIG_fail;
31190 }
31191 {
31192 resultobj = wxPyMake_wxObject(result, 0);
31193 }
31194 return resultobj;
31195 fail:
31196 return NULL;
31197 }
31198
31199
31200 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31201 PyObject *resultobj;
31202 wxString *arg1 = 0 ;
31203 wxWindow *arg2 = (wxWindow *) NULL ;
31204 wxWindow *result;
31205 bool temp1 = false ;
31206 PyObject * obj0 = 0 ;
31207 PyObject * obj1 = 0 ;
31208 char *kwnames[] = {
31209 (char *) "name",(char *) "parent", NULL
31210 };
31211
31212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31213 {
31214 arg1 = wxString_in_helper(obj0);
31215 if (arg1 == NULL) SWIG_fail;
31216 temp1 = true;
31217 }
31218 if (obj1) {
31219 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31220 if (SWIG_arg_fail(2)) SWIG_fail;
31221 }
31222 {
31223 if (!wxPyCheckForApp()) SWIG_fail;
31224 PyThreadState* __tstate = wxPyBeginAllowThreads();
31225 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31226
31227 wxPyEndAllowThreads(__tstate);
31228 if (PyErr_Occurred()) SWIG_fail;
31229 }
31230 {
31231 resultobj = wxPyMake_wxObject(result, 0);
31232 }
31233 {
31234 if (temp1)
31235 delete arg1;
31236 }
31237 return resultobj;
31238 fail:
31239 {
31240 if (temp1)
31241 delete arg1;
31242 }
31243 return NULL;
31244 }
31245
31246
31247 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31248 PyObject *resultobj;
31249 wxString *arg1 = 0 ;
31250 wxWindow *arg2 = (wxWindow *) NULL ;
31251 wxWindow *result;
31252 bool temp1 = false ;
31253 PyObject * obj0 = 0 ;
31254 PyObject * obj1 = 0 ;
31255 char *kwnames[] = {
31256 (char *) "label",(char *) "parent", NULL
31257 };
31258
31259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31260 {
31261 arg1 = wxString_in_helper(obj0);
31262 if (arg1 == NULL) SWIG_fail;
31263 temp1 = true;
31264 }
31265 if (obj1) {
31266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31267 if (SWIG_arg_fail(2)) SWIG_fail;
31268 }
31269 {
31270 if (!wxPyCheckForApp()) SWIG_fail;
31271 PyThreadState* __tstate = wxPyBeginAllowThreads();
31272 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31273
31274 wxPyEndAllowThreads(__tstate);
31275 if (PyErr_Occurred()) SWIG_fail;
31276 }
31277 {
31278 resultobj = wxPyMake_wxObject(result, 0);
31279 }
31280 {
31281 if (temp1)
31282 delete arg1;
31283 }
31284 return resultobj;
31285 fail:
31286 {
31287 if (temp1)
31288 delete arg1;
31289 }
31290 return NULL;
31291 }
31292
31293
31294 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31295 PyObject *resultobj;
31296 wxWindow *arg1 = (wxWindow *) 0 ;
31297 unsigned long arg2 ;
31298 wxWindow *result;
31299 PyObject * obj0 = 0 ;
31300 PyObject * obj1 = 0 ;
31301 char *kwnames[] = {
31302 (char *) "parent",(char *) "_hWnd", NULL
31303 };
31304
31305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31307 if (SWIG_arg_fail(1)) SWIG_fail;
31308 {
31309 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31310 if (SWIG_arg_fail(2)) SWIG_fail;
31311 }
31312 {
31313 PyThreadState* __tstate = wxPyBeginAllowThreads();
31314 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31315
31316 wxPyEndAllowThreads(__tstate);
31317 if (PyErr_Occurred()) SWIG_fail;
31318 }
31319 {
31320 resultobj = wxPyMake_wxObject(result, 0);
31321 }
31322 return resultobj;
31323 fail:
31324 return NULL;
31325 }
31326
31327
31328 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31329 PyObject *resultobj;
31330 wxValidator *result;
31331 char *kwnames[] = {
31332 NULL
31333 };
31334
31335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31336 {
31337 PyThreadState* __tstate = wxPyBeginAllowThreads();
31338 result = (wxValidator *)new wxValidator();
31339
31340 wxPyEndAllowThreads(__tstate);
31341 if (PyErr_Occurred()) SWIG_fail;
31342 }
31343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31344 return resultobj;
31345 fail:
31346 return NULL;
31347 }
31348
31349
31350 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31351 PyObject *resultobj;
31352 wxValidator *arg1 = (wxValidator *) 0 ;
31353 wxValidator *result;
31354 PyObject * obj0 = 0 ;
31355 char *kwnames[] = {
31356 (char *) "self", NULL
31357 };
31358
31359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31361 if (SWIG_arg_fail(1)) SWIG_fail;
31362 {
31363 PyThreadState* __tstate = wxPyBeginAllowThreads();
31364 result = (wxValidator *)(arg1)->Clone();
31365
31366 wxPyEndAllowThreads(__tstate);
31367 if (PyErr_Occurred()) SWIG_fail;
31368 }
31369 {
31370 resultobj = wxPyMake_wxObject(result, 0);
31371 }
31372 return resultobj;
31373 fail:
31374 return NULL;
31375 }
31376
31377
31378 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31379 PyObject *resultobj;
31380 wxValidator *arg1 = (wxValidator *) 0 ;
31381 wxWindow *arg2 = (wxWindow *) 0 ;
31382 bool result;
31383 PyObject * obj0 = 0 ;
31384 PyObject * obj1 = 0 ;
31385 char *kwnames[] = {
31386 (char *) "self",(char *) "parent", NULL
31387 };
31388
31389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31391 if (SWIG_arg_fail(1)) SWIG_fail;
31392 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31393 if (SWIG_arg_fail(2)) SWIG_fail;
31394 {
31395 PyThreadState* __tstate = wxPyBeginAllowThreads();
31396 result = (bool)(arg1)->Validate(arg2);
31397
31398 wxPyEndAllowThreads(__tstate);
31399 if (PyErr_Occurred()) SWIG_fail;
31400 }
31401 {
31402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31403 }
31404 return resultobj;
31405 fail:
31406 return NULL;
31407 }
31408
31409
31410 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31411 PyObject *resultobj;
31412 wxValidator *arg1 = (wxValidator *) 0 ;
31413 bool result;
31414 PyObject * obj0 = 0 ;
31415 char *kwnames[] = {
31416 (char *) "self", NULL
31417 };
31418
31419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31421 if (SWIG_arg_fail(1)) SWIG_fail;
31422 {
31423 PyThreadState* __tstate = wxPyBeginAllowThreads();
31424 result = (bool)(arg1)->TransferToWindow();
31425
31426 wxPyEndAllowThreads(__tstate);
31427 if (PyErr_Occurred()) SWIG_fail;
31428 }
31429 {
31430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31431 }
31432 return resultobj;
31433 fail:
31434 return NULL;
31435 }
31436
31437
31438 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31439 PyObject *resultobj;
31440 wxValidator *arg1 = (wxValidator *) 0 ;
31441 bool result;
31442 PyObject * obj0 = 0 ;
31443 char *kwnames[] = {
31444 (char *) "self", NULL
31445 };
31446
31447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31449 if (SWIG_arg_fail(1)) SWIG_fail;
31450 {
31451 PyThreadState* __tstate = wxPyBeginAllowThreads();
31452 result = (bool)(arg1)->TransferFromWindow();
31453
31454 wxPyEndAllowThreads(__tstate);
31455 if (PyErr_Occurred()) SWIG_fail;
31456 }
31457 {
31458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31459 }
31460 return resultobj;
31461 fail:
31462 return NULL;
31463 }
31464
31465
31466 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31467 PyObject *resultobj;
31468 wxValidator *arg1 = (wxValidator *) 0 ;
31469 wxWindow *result;
31470 PyObject * obj0 = 0 ;
31471 char *kwnames[] = {
31472 (char *) "self", NULL
31473 };
31474
31475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31477 if (SWIG_arg_fail(1)) SWIG_fail;
31478 {
31479 PyThreadState* __tstate = wxPyBeginAllowThreads();
31480 result = (wxWindow *)(arg1)->GetWindow();
31481
31482 wxPyEndAllowThreads(__tstate);
31483 if (PyErr_Occurred()) SWIG_fail;
31484 }
31485 {
31486 resultobj = wxPyMake_wxObject(result, 0);
31487 }
31488 return resultobj;
31489 fail:
31490 return NULL;
31491 }
31492
31493
31494 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31495 PyObject *resultobj;
31496 wxValidator *arg1 = (wxValidator *) 0 ;
31497 wxWindow *arg2 = (wxWindow *) 0 ;
31498 PyObject * obj0 = 0 ;
31499 PyObject * obj1 = 0 ;
31500 char *kwnames[] = {
31501 (char *) "self",(char *) "window", NULL
31502 };
31503
31504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31506 if (SWIG_arg_fail(1)) SWIG_fail;
31507 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31508 if (SWIG_arg_fail(2)) SWIG_fail;
31509 {
31510 PyThreadState* __tstate = wxPyBeginAllowThreads();
31511 (arg1)->SetWindow(arg2);
31512
31513 wxPyEndAllowThreads(__tstate);
31514 if (PyErr_Occurred()) SWIG_fail;
31515 }
31516 Py_INCREF(Py_None); resultobj = Py_None;
31517 return resultobj;
31518 fail:
31519 return NULL;
31520 }
31521
31522
31523 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31524 PyObject *resultobj;
31525 bool result;
31526 char *kwnames[] = {
31527 NULL
31528 };
31529
31530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 result = (bool)wxValidator::IsSilent();
31534
31535 wxPyEndAllowThreads(__tstate);
31536 if (PyErr_Occurred()) SWIG_fail;
31537 }
31538 {
31539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31540 }
31541 return resultobj;
31542 fail:
31543 return NULL;
31544 }
31545
31546
31547 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31548 PyObject *resultobj;
31549 int arg1 = (int) true ;
31550 PyObject * obj0 = 0 ;
31551 char *kwnames[] = {
31552 (char *) "doIt", NULL
31553 };
31554
31555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31556 if (obj0) {
31557 {
31558 arg1 = (int)(SWIG_As_int(obj0));
31559 if (SWIG_arg_fail(1)) SWIG_fail;
31560 }
31561 }
31562 {
31563 PyThreadState* __tstate = wxPyBeginAllowThreads();
31564 wxValidator::SetBellOnError(arg1);
31565
31566 wxPyEndAllowThreads(__tstate);
31567 if (PyErr_Occurred()) SWIG_fail;
31568 }
31569 Py_INCREF(Py_None); resultobj = Py_None;
31570 return resultobj;
31571 fail:
31572 return NULL;
31573 }
31574
31575
31576 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31577 PyObject *obj;
31578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31579 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31580 Py_INCREF(obj);
31581 return Py_BuildValue((char *)"");
31582 }
31583 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31584 PyObject *resultobj;
31585 wxPyValidator *result;
31586 char *kwnames[] = {
31587 NULL
31588 };
31589
31590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31591 {
31592 PyThreadState* __tstate = wxPyBeginAllowThreads();
31593 result = (wxPyValidator *)new wxPyValidator();
31594
31595 wxPyEndAllowThreads(__tstate);
31596 if (PyErr_Occurred()) SWIG_fail;
31597 }
31598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31599 return resultobj;
31600 fail:
31601 return NULL;
31602 }
31603
31604
31605 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31606 PyObject *resultobj;
31607 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31608 PyObject *arg2 = (PyObject *) 0 ;
31609 PyObject *arg3 = (PyObject *) 0 ;
31610 int arg4 = (int) true ;
31611 PyObject * obj0 = 0 ;
31612 PyObject * obj1 = 0 ;
31613 PyObject * obj2 = 0 ;
31614 PyObject * obj3 = 0 ;
31615 char *kwnames[] = {
31616 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
31617 };
31618
31619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
31621 if (SWIG_arg_fail(1)) SWIG_fail;
31622 arg2 = obj1;
31623 arg3 = obj2;
31624 if (obj3) {
31625 {
31626 arg4 = (int)(SWIG_As_int(obj3));
31627 if (SWIG_arg_fail(4)) SWIG_fail;
31628 }
31629 }
31630 {
31631 PyThreadState* __tstate = wxPyBeginAllowThreads();
31632 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
31633
31634 wxPyEndAllowThreads(__tstate);
31635 if (PyErr_Occurred()) SWIG_fail;
31636 }
31637 Py_INCREF(Py_None); resultobj = Py_None;
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
31645 PyObject *obj;
31646 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31647 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
31648 Py_INCREF(obj);
31649 return Py_BuildValue((char *)"");
31650 }
31651 static int _wrap_DefaultValidator_set(PyObject *) {
31652 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
31653 return 1;
31654 }
31655
31656
31657 static PyObject *_wrap_DefaultValidator_get(void) {
31658 PyObject *pyobj;
31659
31660 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
31661 return pyobj;
31662 }
31663
31664
31665 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
31666 PyObject *resultobj;
31667 wxString const &arg1_defvalue = wxPyEmptyString ;
31668 wxString *arg1 = (wxString *) &arg1_defvalue ;
31669 long arg2 = (long) 0 ;
31670 wxMenu *result;
31671 bool temp1 = false ;
31672 PyObject * obj0 = 0 ;
31673 PyObject * obj1 = 0 ;
31674 char *kwnames[] = {
31675 (char *) "title",(char *) "style", NULL
31676 };
31677
31678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
31679 if (obj0) {
31680 {
31681 arg1 = wxString_in_helper(obj0);
31682 if (arg1 == NULL) SWIG_fail;
31683 temp1 = true;
31684 }
31685 }
31686 if (obj1) {
31687 {
31688 arg2 = (long)(SWIG_As_long(obj1));
31689 if (SWIG_arg_fail(2)) SWIG_fail;
31690 }
31691 }
31692 {
31693 if (!wxPyCheckForApp()) SWIG_fail;
31694 PyThreadState* __tstate = wxPyBeginAllowThreads();
31695 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
31696
31697 wxPyEndAllowThreads(__tstate);
31698 if (PyErr_Occurred()) SWIG_fail;
31699 }
31700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
31701 {
31702 if (temp1)
31703 delete arg1;
31704 }
31705 return resultobj;
31706 fail:
31707 {
31708 if (temp1)
31709 delete arg1;
31710 }
31711 return NULL;
31712 }
31713
31714
31715 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
31716 PyObject *resultobj;
31717 wxMenu *arg1 = (wxMenu *) 0 ;
31718 int arg2 ;
31719 wxString *arg3 = 0 ;
31720 wxString const &arg4_defvalue = wxPyEmptyString ;
31721 wxString *arg4 = (wxString *) &arg4_defvalue ;
31722 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
31723 wxMenuItem *result;
31724 bool temp3 = false ;
31725 bool temp4 = false ;
31726 PyObject * obj0 = 0 ;
31727 PyObject * obj1 = 0 ;
31728 PyObject * obj2 = 0 ;
31729 PyObject * obj3 = 0 ;
31730 PyObject * obj4 = 0 ;
31731 char *kwnames[] = {
31732 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
31733 };
31734
31735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
31736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31737 if (SWIG_arg_fail(1)) SWIG_fail;
31738 {
31739 arg2 = (int)(SWIG_As_int(obj1));
31740 if (SWIG_arg_fail(2)) SWIG_fail;
31741 }
31742 {
31743 arg3 = wxString_in_helper(obj2);
31744 if (arg3 == NULL) SWIG_fail;
31745 temp3 = true;
31746 }
31747 if (obj3) {
31748 {
31749 arg4 = wxString_in_helper(obj3);
31750 if (arg4 == NULL) SWIG_fail;
31751 temp4 = true;
31752 }
31753 }
31754 if (obj4) {
31755 {
31756 arg5 = (wxItemKind)(SWIG_As_int(obj4));
31757 if (SWIG_arg_fail(5)) SWIG_fail;
31758 }
31759 }
31760 {
31761 PyThreadState* __tstate = wxPyBeginAllowThreads();
31762 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
31763
31764 wxPyEndAllowThreads(__tstate);
31765 if (PyErr_Occurred()) SWIG_fail;
31766 }
31767 {
31768 resultobj = wxPyMake_wxObject(result, 0);
31769 }
31770 {
31771 if (temp3)
31772 delete arg3;
31773 }
31774 {
31775 if (temp4)
31776 delete arg4;
31777 }
31778 return resultobj;
31779 fail:
31780 {
31781 if (temp3)
31782 delete arg3;
31783 }
31784 {
31785 if (temp4)
31786 delete arg4;
31787 }
31788 return NULL;
31789 }
31790
31791
31792 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
31793 PyObject *resultobj;
31794 wxMenu *arg1 = (wxMenu *) 0 ;
31795 wxMenuItem *result;
31796 PyObject * obj0 = 0 ;
31797 char *kwnames[] = {
31798 (char *) "self", NULL
31799 };
31800
31801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
31802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31803 if (SWIG_arg_fail(1)) SWIG_fail;
31804 {
31805 PyThreadState* __tstate = wxPyBeginAllowThreads();
31806 result = (wxMenuItem *)(arg1)->AppendSeparator();
31807
31808 wxPyEndAllowThreads(__tstate);
31809 if (PyErr_Occurred()) SWIG_fail;
31810 }
31811 {
31812 resultobj = wxPyMake_wxObject(result, 0);
31813 }
31814 return resultobj;
31815 fail:
31816 return NULL;
31817 }
31818
31819
31820 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
31821 PyObject *resultobj;
31822 wxMenu *arg1 = (wxMenu *) 0 ;
31823 int arg2 ;
31824 wxString *arg3 = 0 ;
31825 wxString const &arg4_defvalue = wxPyEmptyString ;
31826 wxString *arg4 = (wxString *) &arg4_defvalue ;
31827 wxMenuItem *result;
31828 bool temp3 = false ;
31829 bool temp4 = false ;
31830 PyObject * obj0 = 0 ;
31831 PyObject * obj1 = 0 ;
31832 PyObject * obj2 = 0 ;
31833 PyObject * obj3 = 0 ;
31834 char *kwnames[] = {
31835 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31836 };
31837
31838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31840 if (SWIG_arg_fail(1)) SWIG_fail;
31841 {
31842 arg2 = (int)(SWIG_As_int(obj1));
31843 if (SWIG_arg_fail(2)) SWIG_fail;
31844 }
31845 {
31846 arg3 = wxString_in_helper(obj2);
31847 if (arg3 == NULL) SWIG_fail;
31848 temp3 = true;
31849 }
31850 if (obj3) {
31851 {
31852 arg4 = wxString_in_helper(obj3);
31853 if (arg4 == NULL) SWIG_fail;
31854 temp4 = true;
31855 }
31856 }
31857 {
31858 PyThreadState* __tstate = wxPyBeginAllowThreads();
31859 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
31860
31861 wxPyEndAllowThreads(__tstate);
31862 if (PyErr_Occurred()) SWIG_fail;
31863 }
31864 {
31865 resultobj = wxPyMake_wxObject(result, 0);
31866 }
31867 {
31868 if (temp3)
31869 delete arg3;
31870 }
31871 {
31872 if (temp4)
31873 delete arg4;
31874 }
31875 return resultobj;
31876 fail:
31877 {
31878 if (temp3)
31879 delete arg3;
31880 }
31881 {
31882 if (temp4)
31883 delete arg4;
31884 }
31885 return NULL;
31886 }
31887
31888
31889 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
31890 PyObject *resultobj;
31891 wxMenu *arg1 = (wxMenu *) 0 ;
31892 int arg2 ;
31893 wxString *arg3 = 0 ;
31894 wxString const &arg4_defvalue = wxPyEmptyString ;
31895 wxString *arg4 = (wxString *) &arg4_defvalue ;
31896 wxMenuItem *result;
31897 bool temp3 = false ;
31898 bool temp4 = false ;
31899 PyObject * obj0 = 0 ;
31900 PyObject * obj1 = 0 ;
31901 PyObject * obj2 = 0 ;
31902 PyObject * obj3 = 0 ;
31903 char *kwnames[] = {
31904 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
31905 };
31906
31907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31909 if (SWIG_arg_fail(1)) SWIG_fail;
31910 {
31911 arg2 = (int)(SWIG_As_int(obj1));
31912 if (SWIG_arg_fail(2)) SWIG_fail;
31913 }
31914 {
31915 arg3 = wxString_in_helper(obj2);
31916 if (arg3 == NULL) SWIG_fail;
31917 temp3 = true;
31918 }
31919 if (obj3) {
31920 {
31921 arg4 = wxString_in_helper(obj3);
31922 if (arg4 == NULL) SWIG_fail;
31923 temp4 = true;
31924 }
31925 }
31926 {
31927 PyThreadState* __tstate = wxPyBeginAllowThreads();
31928 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
31929
31930 wxPyEndAllowThreads(__tstate);
31931 if (PyErr_Occurred()) SWIG_fail;
31932 }
31933 {
31934 resultobj = wxPyMake_wxObject(result, 0);
31935 }
31936 {
31937 if (temp3)
31938 delete arg3;
31939 }
31940 {
31941 if (temp4)
31942 delete arg4;
31943 }
31944 return resultobj;
31945 fail:
31946 {
31947 if (temp3)
31948 delete arg3;
31949 }
31950 {
31951 if (temp4)
31952 delete arg4;
31953 }
31954 return NULL;
31955 }
31956
31957
31958 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31959 PyObject *resultobj;
31960 wxMenu *arg1 = (wxMenu *) 0 ;
31961 int arg2 ;
31962 wxString *arg3 = 0 ;
31963 wxMenu *arg4 = (wxMenu *) 0 ;
31964 wxString const &arg5_defvalue = wxPyEmptyString ;
31965 wxString *arg5 = (wxString *) &arg5_defvalue ;
31966 wxMenuItem *result;
31967 bool temp3 = false ;
31968 bool temp5 = false ;
31969 PyObject * obj0 = 0 ;
31970 PyObject * obj1 = 0 ;
31971 PyObject * obj2 = 0 ;
31972 PyObject * obj3 = 0 ;
31973 PyObject * obj4 = 0 ;
31974 char *kwnames[] = {
31975 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
31976 };
31977
31978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
31979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31980 if (SWIG_arg_fail(1)) SWIG_fail;
31981 {
31982 arg2 = (int)(SWIG_As_int(obj1));
31983 if (SWIG_arg_fail(2)) SWIG_fail;
31984 }
31985 {
31986 arg3 = wxString_in_helper(obj2);
31987 if (arg3 == NULL) SWIG_fail;
31988 temp3 = true;
31989 }
31990 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31991 if (SWIG_arg_fail(4)) SWIG_fail;
31992 if (obj4) {
31993 {
31994 arg5 = wxString_in_helper(obj4);
31995 if (arg5 == NULL) SWIG_fail;
31996 temp5 = true;
31997 }
31998 }
31999 {
32000 PyThreadState* __tstate = wxPyBeginAllowThreads();
32001 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32002
32003 wxPyEndAllowThreads(__tstate);
32004 if (PyErr_Occurred()) SWIG_fail;
32005 }
32006 {
32007 resultobj = wxPyMake_wxObject(result, 0);
32008 }
32009 {
32010 if (temp3)
32011 delete arg3;
32012 }
32013 {
32014 if (temp5)
32015 delete arg5;
32016 }
32017 return resultobj;
32018 fail:
32019 {
32020 if (temp3)
32021 delete arg3;
32022 }
32023 {
32024 if (temp5)
32025 delete arg5;
32026 }
32027 return NULL;
32028 }
32029
32030
32031 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32032 PyObject *resultobj;
32033 wxMenu *arg1 = (wxMenu *) 0 ;
32034 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32035 wxMenuItem *result;
32036 PyObject * obj0 = 0 ;
32037 PyObject * obj1 = 0 ;
32038 char *kwnames[] = {
32039 (char *) "self",(char *) "item", NULL
32040 };
32041
32042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32044 if (SWIG_arg_fail(1)) SWIG_fail;
32045 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32046 if (SWIG_arg_fail(2)) SWIG_fail;
32047 {
32048 PyThreadState* __tstate = wxPyBeginAllowThreads();
32049 result = (wxMenuItem *)(arg1)->Append(arg2);
32050
32051 wxPyEndAllowThreads(__tstate);
32052 if (PyErr_Occurred()) SWIG_fail;
32053 }
32054 {
32055 resultobj = wxPyMake_wxObject(result, 0);
32056 }
32057 return resultobj;
32058 fail:
32059 return NULL;
32060 }
32061
32062
32063 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32064 PyObject *resultobj;
32065 wxMenu *arg1 = (wxMenu *) 0 ;
32066 PyObject * obj0 = 0 ;
32067 char *kwnames[] = {
32068 (char *) "self", NULL
32069 };
32070
32071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32073 if (SWIG_arg_fail(1)) SWIG_fail;
32074 {
32075 PyThreadState* __tstate = wxPyBeginAllowThreads();
32076 (arg1)->Break();
32077
32078 wxPyEndAllowThreads(__tstate);
32079 if (PyErr_Occurred()) SWIG_fail;
32080 }
32081 Py_INCREF(Py_None); resultobj = Py_None;
32082 return resultobj;
32083 fail:
32084 return NULL;
32085 }
32086
32087
32088 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32089 PyObject *resultobj;
32090 wxMenu *arg1 = (wxMenu *) 0 ;
32091 size_t arg2 ;
32092 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32093 wxMenuItem *result;
32094 PyObject * obj0 = 0 ;
32095 PyObject * obj1 = 0 ;
32096 PyObject * obj2 = 0 ;
32097 char *kwnames[] = {
32098 (char *) "self",(char *) "pos",(char *) "item", NULL
32099 };
32100
32101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32103 if (SWIG_arg_fail(1)) SWIG_fail;
32104 {
32105 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32106 if (SWIG_arg_fail(2)) SWIG_fail;
32107 }
32108 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32109 if (SWIG_arg_fail(3)) SWIG_fail;
32110 {
32111 PyThreadState* __tstate = wxPyBeginAllowThreads();
32112 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32113
32114 wxPyEndAllowThreads(__tstate);
32115 if (PyErr_Occurred()) SWIG_fail;
32116 }
32117 {
32118 resultobj = wxPyMake_wxObject(result, 0);
32119 }
32120 return resultobj;
32121 fail:
32122 return NULL;
32123 }
32124
32125
32126 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32127 PyObject *resultobj;
32128 wxMenu *arg1 = (wxMenu *) 0 ;
32129 size_t arg2 ;
32130 int arg3 ;
32131 wxString *arg4 = 0 ;
32132 wxString const &arg5_defvalue = wxPyEmptyString ;
32133 wxString *arg5 = (wxString *) &arg5_defvalue ;
32134 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32135 wxMenuItem *result;
32136 bool temp4 = false ;
32137 bool temp5 = false ;
32138 PyObject * obj0 = 0 ;
32139 PyObject * obj1 = 0 ;
32140 PyObject * obj2 = 0 ;
32141 PyObject * obj3 = 0 ;
32142 PyObject * obj4 = 0 ;
32143 PyObject * obj5 = 0 ;
32144 char *kwnames[] = {
32145 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32146 };
32147
32148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32150 if (SWIG_arg_fail(1)) SWIG_fail;
32151 {
32152 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32153 if (SWIG_arg_fail(2)) SWIG_fail;
32154 }
32155 {
32156 arg3 = (int)(SWIG_As_int(obj2));
32157 if (SWIG_arg_fail(3)) SWIG_fail;
32158 }
32159 {
32160 arg4 = wxString_in_helper(obj3);
32161 if (arg4 == NULL) SWIG_fail;
32162 temp4 = true;
32163 }
32164 if (obj4) {
32165 {
32166 arg5 = wxString_in_helper(obj4);
32167 if (arg5 == NULL) SWIG_fail;
32168 temp5 = true;
32169 }
32170 }
32171 if (obj5) {
32172 {
32173 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32174 if (SWIG_arg_fail(6)) SWIG_fail;
32175 }
32176 }
32177 {
32178 PyThreadState* __tstate = wxPyBeginAllowThreads();
32179 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32180
32181 wxPyEndAllowThreads(__tstate);
32182 if (PyErr_Occurred()) SWIG_fail;
32183 }
32184 {
32185 resultobj = wxPyMake_wxObject(result, 0);
32186 }
32187 {
32188 if (temp4)
32189 delete arg4;
32190 }
32191 {
32192 if (temp5)
32193 delete arg5;
32194 }
32195 return resultobj;
32196 fail:
32197 {
32198 if (temp4)
32199 delete arg4;
32200 }
32201 {
32202 if (temp5)
32203 delete arg5;
32204 }
32205 return NULL;
32206 }
32207
32208
32209 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32210 PyObject *resultobj;
32211 wxMenu *arg1 = (wxMenu *) 0 ;
32212 size_t arg2 ;
32213 wxMenuItem *result;
32214 PyObject * obj0 = 0 ;
32215 PyObject * obj1 = 0 ;
32216 char *kwnames[] = {
32217 (char *) "self",(char *) "pos", NULL
32218 };
32219
32220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32222 if (SWIG_arg_fail(1)) SWIG_fail;
32223 {
32224 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32225 if (SWIG_arg_fail(2)) SWIG_fail;
32226 }
32227 {
32228 PyThreadState* __tstate = wxPyBeginAllowThreads();
32229 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32230
32231 wxPyEndAllowThreads(__tstate);
32232 if (PyErr_Occurred()) SWIG_fail;
32233 }
32234 {
32235 resultobj = wxPyMake_wxObject(result, 0);
32236 }
32237 return resultobj;
32238 fail:
32239 return NULL;
32240 }
32241
32242
32243 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32244 PyObject *resultobj;
32245 wxMenu *arg1 = (wxMenu *) 0 ;
32246 size_t arg2 ;
32247 int arg3 ;
32248 wxString *arg4 = 0 ;
32249 wxString const &arg5_defvalue = wxPyEmptyString ;
32250 wxString *arg5 = (wxString *) &arg5_defvalue ;
32251 wxMenuItem *result;
32252 bool temp4 = false ;
32253 bool temp5 = false ;
32254 PyObject * obj0 = 0 ;
32255 PyObject * obj1 = 0 ;
32256 PyObject * obj2 = 0 ;
32257 PyObject * obj3 = 0 ;
32258 PyObject * obj4 = 0 ;
32259 char *kwnames[] = {
32260 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32261 };
32262
32263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32265 if (SWIG_arg_fail(1)) SWIG_fail;
32266 {
32267 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32268 if (SWIG_arg_fail(2)) SWIG_fail;
32269 }
32270 {
32271 arg3 = (int)(SWIG_As_int(obj2));
32272 if (SWIG_arg_fail(3)) SWIG_fail;
32273 }
32274 {
32275 arg4 = wxString_in_helper(obj3);
32276 if (arg4 == NULL) SWIG_fail;
32277 temp4 = true;
32278 }
32279 if (obj4) {
32280 {
32281 arg5 = wxString_in_helper(obj4);
32282 if (arg5 == NULL) SWIG_fail;
32283 temp5 = true;
32284 }
32285 }
32286 {
32287 PyThreadState* __tstate = wxPyBeginAllowThreads();
32288 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32289
32290 wxPyEndAllowThreads(__tstate);
32291 if (PyErr_Occurred()) SWIG_fail;
32292 }
32293 {
32294 resultobj = wxPyMake_wxObject(result, 0);
32295 }
32296 {
32297 if (temp4)
32298 delete arg4;
32299 }
32300 {
32301 if (temp5)
32302 delete arg5;
32303 }
32304 return resultobj;
32305 fail:
32306 {
32307 if (temp4)
32308 delete arg4;
32309 }
32310 {
32311 if (temp5)
32312 delete arg5;
32313 }
32314 return NULL;
32315 }
32316
32317
32318 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32319 PyObject *resultobj;
32320 wxMenu *arg1 = (wxMenu *) 0 ;
32321 size_t arg2 ;
32322 int arg3 ;
32323 wxString *arg4 = 0 ;
32324 wxString const &arg5_defvalue = wxPyEmptyString ;
32325 wxString *arg5 = (wxString *) &arg5_defvalue ;
32326 wxMenuItem *result;
32327 bool temp4 = false ;
32328 bool temp5 = false ;
32329 PyObject * obj0 = 0 ;
32330 PyObject * obj1 = 0 ;
32331 PyObject * obj2 = 0 ;
32332 PyObject * obj3 = 0 ;
32333 PyObject * obj4 = 0 ;
32334 char *kwnames[] = {
32335 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32336 };
32337
32338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32340 if (SWIG_arg_fail(1)) SWIG_fail;
32341 {
32342 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32343 if (SWIG_arg_fail(2)) SWIG_fail;
32344 }
32345 {
32346 arg3 = (int)(SWIG_As_int(obj2));
32347 if (SWIG_arg_fail(3)) SWIG_fail;
32348 }
32349 {
32350 arg4 = wxString_in_helper(obj3);
32351 if (arg4 == NULL) SWIG_fail;
32352 temp4 = true;
32353 }
32354 if (obj4) {
32355 {
32356 arg5 = wxString_in_helper(obj4);
32357 if (arg5 == NULL) SWIG_fail;
32358 temp5 = true;
32359 }
32360 }
32361 {
32362 PyThreadState* __tstate = wxPyBeginAllowThreads();
32363 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32364
32365 wxPyEndAllowThreads(__tstate);
32366 if (PyErr_Occurred()) SWIG_fail;
32367 }
32368 {
32369 resultobj = wxPyMake_wxObject(result, 0);
32370 }
32371 {
32372 if (temp4)
32373 delete arg4;
32374 }
32375 {
32376 if (temp5)
32377 delete arg5;
32378 }
32379 return resultobj;
32380 fail:
32381 {
32382 if (temp4)
32383 delete arg4;
32384 }
32385 {
32386 if (temp5)
32387 delete arg5;
32388 }
32389 return NULL;
32390 }
32391
32392
32393 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32394 PyObject *resultobj;
32395 wxMenu *arg1 = (wxMenu *) 0 ;
32396 size_t arg2 ;
32397 int arg3 ;
32398 wxString *arg4 = 0 ;
32399 wxMenu *arg5 = (wxMenu *) 0 ;
32400 wxString const &arg6_defvalue = wxPyEmptyString ;
32401 wxString *arg6 = (wxString *) &arg6_defvalue ;
32402 wxMenuItem *result;
32403 bool temp4 = false ;
32404 bool temp6 = false ;
32405 PyObject * obj0 = 0 ;
32406 PyObject * obj1 = 0 ;
32407 PyObject * obj2 = 0 ;
32408 PyObject * obj3 = 0 ;
32409 PyObject * obj4 = 0 ;
32410 PyObject * obj5 = 0 ;
32411 char *kwnames[] = {
32412 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32413 };
32414
32415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32417 if (SWIG_arg_fail(1)) SWIG_fail;
32418 {
32419 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32420 if (SWIG_arg_fail(2)) SWIG_fail;
32421 }
32422 {
32423 arg3 = (int)(SWIG_As_int(obj2));
32424 if (SWIG_arg_fail(3)) SWIG_fail;
32425 }
32426 {
32427 arg4 = wxString_in_helper(obj3);
32428 if (arg4 == NULL) SWIG_fail;
32429 temp4 = true;
32430 }
32431 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32432 if (SWIG_arg_fail(5)) SWIG_fail;
32433 if (obj5) {
32434 {
32435 arg6 = wxString_in_helper(obj5);
32436 if (arg6 == NULL) SWIG_fail;
32437 temp6 = true;
32438 }
32439 }
32440 {
32441 PyThreadState* __tstate = wxPyBeginAllowThreads();
32442 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32443
32444 wxPyEndAllowThreads(__tstate);
32445 if (PyErr_Occurred()) SWIG_fail;
32446 }
32447 {
32448 resultobj = wxPyMake_wxObject(result, 0);
32449 }
32450 {
32451 if (temp4)
32452 delete arg4;
32453 }
32454 {
32455 if (temp6)
32456 delete arg6;
32457 }
32458 return resultobj;
32459 fail:
32460 {
32461 if (temp4)
32462 delete arg4;
32463 }
32464 {
32465 if (temp6)
32466 delete arg6;
32467 }
32468 return NULL;
32469 }
32470
32471
32472 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32473 PyObject *resultobj;
32474 wxMenu *arg1 = (wxMenu *) 0 ;
32475 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32476 wxMenuItem *result;
32477 PyObject * obj0 = 0 ;
32478 PyObject * obj1 = 0 ;
32479 char *kwnames[] = {
32480 (char *) "self",(char *) "item", NULL
32481 };
32482
32483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32485 if (SWIG_arg_fail(1)) SWIG_fail;
32486 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32487 if (SWIG_arg_fail(2)) SWIG_fail;
32488 {
32489 PyThreadState* __tstate = wxPyBeginAllowThreads();
32490 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32491
32492 wxPyEndAllowThreads(__tstate);
32493 if (PyErr_Occurred()) SWIG_fail;
32494 }
32495 {
32496 resultobj = wxPyMake_wxObject(result, 0);
32497 }
32498 return resultobj;
32499 fail:
32500 return NULL;
32501 }
32502
32503
32504 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32505 PyObject *resultobj;
32506 wxMenu *arg1 = (wxMenu *) 0 ;
32507 int arg2 ;
32508 wxString *arg3 = 0 ;
32509 wxString const &arg4_defvalue = wxPyEmptyString ;
32510 wxString *arg4 = (wxString *) &arg4_defvalue ;
32511 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32512 wxMenuItem *result;
32513 bool temp3 = false ;
32514 bool temp4 = false ;
32515 PyObject * obj0 = 0 ;
32516 PyObject * obj1 = 0 ;
32517 PyObject * obj2 = 0 ;
32518 PyObject * obj3 = 0 ;
32519 PyObject * obj4 = 0 ;
32520 char *kwnames[] = {
32521 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32522 };
32523
32524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32526 if (SWIG_arg_fail(1)) SWIG_fail;
32527 {
32528 arg2 = (int)(SWIG_As_int(obj1));
32529 if (SWIG_arg_fail(2)) SWIG_fail;
32530 }
32531 {
32532 arg3 = wxString_in_helper(obj2);
32533 if (arg3 == NULL) SWIG_fail;
32534 temp3 = true;
32535 }
32536 if (obj3) {
32537 {
32538 arg4 = wxString_in_helper(obj3);
32539 if (arg4 == NULL) SWIG_fail;
32540 temp4 = true;
32541 }
32542 }
32543 if (obj4) {
32544 {
32545 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32546 if (SWIG_arg_fail(5)) SWIG_fail;
32547 }
32548 }
32549 {
32550 PyThreadState* __tstate = wxPyBeginAllowThreads();
32551 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32552
32553 wxPyEndAllowThreads(__tstate);
32554 if (PyErr_Occurred()) SWIG_fail;
32555 }
32556 {
32557 resultobj = wxPyMake_wxObject(result, 0);
32558 }
32559 {
32560 if (temp3)
32561 delete arg3;
32562 }
32563 {
32564 if (temp4)
32565 delete arg4;
32566 }
32567 return resultobj;
32568 fail:
32569 {
32570 if (temp3)
32571 delete arg3;
32572 }
32573 {
32574 if (temp4)
32575 delete arg4;
32576 }
32577 return NULL;
32578 }
32579
32580
32581 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32582 PyObject *resultobj;
32583 wxMenu *arg1 = (wxMenu *) 0 ;
32584 wxMenuItem *result;
32585 PyObject * obj0 = 0 ;
32586 char *kwnames[] = {
32587 (char *) "self", NULL
32588 };
32589
32590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32592 if (SWIG_arg_fail(1)) SWIG_fail;
32593 {
32594 PyThreadState* __tstate = wxPyBeginAllowThreads();
32595 result = (wxMenuItem *)(arg1)->PrependSeparator();
32596
32597 wxPyEndAllowThreads(__tstate);
32598 if (PyErr_Occurred()) SWIG_fail;
32599 }
32600 {
32601 resultobj = wxPyMake_wxObject(result, 0);
32602 }
32603 return resultobj;
32604 fail:
32605 return NULL;
32606 }
32607
32608
32609 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32610 PyObject *resultobj;
32611 wxMenu *arg1 = (wxMenu *) 0 ;
32612 int arg2 ;
32613 wxString *arg3 = 0 ;
32614 wxString const &arg4_defvalue = wxPyEmptyString ;
32615 wxString *arg4 = (wxString *) &arg4_defvalue ;
32616 wxMenuItem *result;
32617 bool temp3 = false ;
32618 bool temp4 = false ;
32619 PyObject * obj0 = 0 ;
32620 PyObject * obj1 = 0 ;
32621 PyObject * obj2 = 0 ;
32622 PyObject * obj3 = 0 ;
32623 char *kwnames[] = {
32624 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32625 };
32626
32627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32629 if (SWIG_arg_fail(1)) SWIG_fail;
32630 {
32631 arg2 = (int)(SWIG_As_int(obj1));
32632 if (SWIG_arg_fail(2)) SWIG_fail;
32633 }
32634 {
32635 arg3 = wxString_in_helper(obj2);
32636 if (arg3 == NULL) SWIG_fail;
32637 temp3 = true;
32638 }
32639 if (obj3) {
32640 {
32641 arg4 = wxString_in_helper(obj3);
32642 if (arg4 == NULL) SWIG_fail;
32643 temp4 = true;
32644 }
32645 }
32646 {
32647 PyThreadState* __tstate = wxPyBeginAllowThreads();
32648 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32649
32650 wxPyEndAllowThreads(__tstate);
32651 if (PyErr_Occurred()) SWIG_fail;
32652 }
32653 {
32654 resultobj = wxPyMake_wxObject(result, 0);
32655 }
32656 {
32657 if (temp3)
32658 delete arg3;
32659 }
32660 {
32661 if (temp4)
32662 delete arg4;
32663 }
32664 return resultobj;
32665 fail:
32666 {
32667 if (temp3)
32668 delete arg3;
32669 }
32670 {
32671 if (temp4)
32672 delete arg4;
32673 }
32674 return NULL;
32675 }
32676
32677
32678 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32679 PyObject *resultobj;
32680 wxMenu *arg1 = (wxMenu *) 0 ;
32681 int arg2 ;
32682 wxString *arg3 = 0 ;
32683 wxString const &arg4_defvalue = wxPyEmptyString ;
32684 wxString *arg4 = (wxString *) &arg4_defvalue ;
32685 wxMenuItem *result;
32686 bool temp3 = false ;
32687 bool temp4 = false ;
32688 PyObject * obj0 = 0 ;
32689 PyObject * obj1 = 0 ;
32690 PyObject * obj2 = 0 ;
32691 PyObject * obj3 = 0 ;
32692 char *kwnames[] = {
32693 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32694 };
32695
32696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32698 if (SWIG_arg_fail(1)) SWIG_fail;
32699 {
32700 arg2 = (int)(SWIG_As_int(obj1));
32701 if (SWIG_arg_fail(2)) SWIG_fail;
32702 }
32703 {
32704 arg3 = wxString_in_helper(obj2);
32705 if (arg3 == NULL) SWIG_fail;
32706 temp3 = true;
32707 }
32708 if (obj3) {
32709 {
32710 arg4 = wxString_in_helper(obj3);
32711 if (arg4 == NULL) SWIG_fail;
32712 temp4 = true;
32713 }
32714 }
32715 {
32716 PyThreadState* __tstate = wxPyBeginAllowThreads();
32717 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32718
32719 wxPyEndAllowThreads(__tstate);
32720 if (PyErr_Occurred()) SWIG_fail;
32721 }
32722 {
32723 resultobj = wxPyMake_wxObject(result, 0);
32724 }
32725 {
32726 if (temp3)
32727 delete arg3;
32728 }
32729 {
32730 if (temp4)
32731 delete arg4;
32732 }
32733 return resultobj;
32734 fail:
32735 {
32736 if (temp3)
32737 delete arg3;
32738 }
32739 {
32740 if (temp4)
32741 delete arg4;
32742 }
32743 return NULL;
32744 }
32745
32746
32747 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32748 PyObject *resultobj;
32749 wxMenu *arg1 = (wxMenu *) 0 ;
32750 int arg2 ;
32751 wxString *arg3 = 0 ;
32752 wxMenu *arg4 = (wxMenu *) 0 ;
32753 wxString const &arg5_defvalue = wxPyEmptyString ;
32754 wxString *arg5 = (wxString *) &arg5_defvalue ;
32755 wxMenuItem *result;
32756 bool temp3 = false ;
32757 bool temp5 = false ;
32758 PyObject * obj0 = 0 ;
32759 PyObject * obj1 = 0 ;
32760 PyObject * obj2 = 0 ;
32761 PyObject * obj3 = 0 ;
32762 PyObject * obj4 = 0 ;
32763 char *kwnames[] = {
32764 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32765 };
32766
32767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32769 if (SWIG_arg_fail(1)) SWIG_fail;
32770 {
32771 arg2 = (int)(SWIG_As_int(obj1));
32772 if (SWIG_arg_fail(2)) SWIG_fail;
32773 }
32774 {
32775 arg3 = wxString_in_helper(obj2);
32776 if (arg3 == NULL) SWIG_fail;
32777 temp3 = true;
32778 }
32779 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32780 if (SWIG_arg_fail(4)) SWIG_fail;
32781 if (obj4) {
32782 {
32783 arg5 = wxString_in_helper(obj4);
32784 if (arg5 == NULL) SWIG_fail;
32785 temp5 = true;
32786 }
32787 }
32788 {
32789 PyThreadState* __tstate = wxPyBeginAllowThreads();
32790 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32791
32792 wxPyEndAllowThreads(__tstate);
32793 if (PyErr_Occurred()) SWIG_fail;
32794 }
32795 {
32796 resultobj = wxPyMake_wxObject(result, 0);
32797 }
32798 {
32799 if (temp3)
32800 delete arg3;
32801 }
32802 {
32803 if (temp5)
32804 delete arg5;
32805 }
32806 return resultobj;
32807 fail:
32808 {
32809 if (temp3)
32810 delete arg3;
32811 }
32812 {
32813 if (temp5)
32814 delete arg5;
32815 }
32816 return NULL;
32817 }
32818
32819
32820 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
32821 PyObject *resultobj;
32822 wxMenu *arg1 = (wxMenu *) 0 ;
32823 int arg2 ;
32824 wxMenuItem *result;
32825 PyObject * obj0 = 0 ;
32826 PyObject * obj1 = 0 ;
32827 char *kwnames[] = {
32828 (char *) "self",(char *) "id", NULL
32829 };
32830
32831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
32832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32833 if (SWIG_arg_fail(1)) SWIG_fail;
32834 {
32835 arg2 = (int)(SWIG_As_int(obj1));
32836 if (SWIG_arg_fail(2)) SWIG_fail;
32837 }
32838 {
32839 PyThreadState* __tstate = wxPyBeginAllowThreads();
32840 result = (wxMenuItem *)(arg1)->Remove(arg2);
32841
32842 wxPyEndAllowThreads(__tstate);
32843 if (PyErr_Occurred()) SWIG_fail;
32844 }
32845 {
32846 resultobj = wxPyMake_wxObject(result, 0);
32847 }
32848 return resultobj;
32849 fail:
32850 return NULL;
32851 }
32852
32853
32854 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
32855 PyObject *resultobj;
32856 wxMenu *arg1 = (wxMenu *) 0 ;
32857 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32858 wxMenuItem *result;
32859 PyObject * obj0 = 0 ;
32860 PyObject * obj1 = 0 ;
32861 char *kwnames[] = {
32862 (char *) "self",(char *) "item", NULL
32863 };
32864
32865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
32866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32867 if (SWIG_arg_fail(1)) SWIG_fail;
32868 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32869 if (SWIG_arg_fail(2)) SWIG_fail;
32870 {
32871 PyThreadState* __tstate = wxPyBeginAllowThreads();
32872 result = (wxMenuItem *)(arg1)->Remove(arg2);
32873
32874 wxPyEndAllowThreads(__tstate);
32875 if (PyErr_Occurred()) SWIG_fail;
32876 }
32877 {
32878 resultobj = wxPyMake_wxObject(result, 0);
32879 }
32880 return resultobj;
32881 fail:
32882 return NULL;
32883 }
32884
32885
32886 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
32887 PyObject *resultobj;
32888 wxMenu *arg1 = (wxMenu *) 0 ;
32889 int arg2 ;
32890 bool result;
32891 PyObject * obj0 = 0 ;
32892 PyObject * obj1 = 0 ;
32893 char *kwnames[] = {
32894 (char *) "self",(char *) "id", NULL
32895 };
32896
32897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
32898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32899 if (SWIG_arg_fail(1)) SWIG_fail;
32900 {
32901 arg2 = (int)(SWIG_As_int(obj1));
32902 if (SWIG_arg_fail(2)) SWIG_fail;
32903 }
32904 {
32905 PyThreadState* __tstate = wxPyBeginAllowThreads();
32906 result = (bool)(arg1)->Delete(arg2);
32907
32908 wxPyEndAllowThreads(__tstate);
32909 if (PyErr_Occurred()) SWIG_fail;
32910 }
32911 {
32912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32913 }
32914 return resultobj;
32915 fail:
32916 return NULL;
32917 }
32918
32919
32920 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
32921 PyObject *resultobj;
32922 wxMenu *arg1 = (wxMenu *) 0 ;
32923 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32924 bool result;
32925 PyObject * obj0 = 0 ;
32926 PyObject * obj1 = 0 ;
32927 char *kwnames[] = {
32928 (char *) "self",(char *) "item", NULL
32929 };
32930
32931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
32932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32933 if (SWIG_arg_fail(1)) SWIG_fail;
32934 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32935 if (SWIG_arg_fail(2)) SWIG_fail;
32936 {
32937 PyThreadState* __tstate = wxPyBeginAllowThreads();
32938 result = (bool)(arg1)->Delete(arg2);
32939
32940 wxPyEndAllowThreads(__tstate);
32941 if (PyErr_Occurred()) SWIG_fail;
32942 }
32943 {
32944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32945 }
32946 return resultobj;
32947 fail:
32948 return NULL;
32949 }
32950
32951
32952 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
32953 PyObject *resultobj;
32954 wxMenu *arg1 = (wxMenu *) 0 ;
32955 PyObject * obj0 = 0 ;
32956 char *kwnames[] = {
32957 (char *) "self", NULL
32958 };
32959
32960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
32961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32962 if (SWIG_arg_fail(1)) SWIG_fail;
32963 {
32964 PyThreadState* __tstate = wxPyBeginAllowThreads();
32965 wxMenu_Destroy(arg1);
32966
32967 wxPyEndAllowThreads(__tstate);
32968 if (PyErr_Occurred()) SWIG_fail;
32969 }
32970 Py_INCREF(Py_None); resultobj = Py_None;
32971 return resultobj;
32972 fail:
32973 return NULL;
32974 }
32975
32976
32977 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
32978 PyObject *resultobj;
32979 wxMenu *arg1 = (wxMenu *) 0 ;
32980 int arg2 ;
32981 bool result;
32982 PyObject * obj0 = 0 ;
32983 PyObject * obj1 = 0 ;
32984 char *kwnames[] = {
32985 (char *) "self",(char *) "id", NULL
32986 };
32987
32988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
32989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32990 if (SWIG_arg_fail(1)) SWIG_fail;
32991 {
32992 arg2 = (int)(SWIG_As_int(obj1));
32993 if (SWIG_arg_fail(2)) SWIG_fail;
32994 }
32995 {
32996 PyThreadState* __tstate = wxPyBeginAllowThreads();
32997 result = (bool)(arg1)->Destroy(arg2);
32998
32999 wxPyEndAllowThreads(__tstate);
33000 if (PyErr_Occurred()) SWIG_fail;
33001 }
33002 {
33003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33004 }
33005 return resultobj;
33006 fail:
33007 return NULL;
33008 }
33009
33010
33011 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33012 PyObject *resultobj;
33013 wxMenu *arg1 = (wxMenu *) 0 ;
33014 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33015 bool result;
33016 PyObject * obj0 = 0 ;
33017 PyObject * obj1 = 0 ;
33018 char *kwnames[] = {
33019 (char *) "self",(char *) "item", NULL
33020 };
33021
33022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33024 if (SWIG_arg_fail(1)) SWIG_fail;
33025 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33026 if (SWIG_arg_fail(2)) SWIG_fail;
33027 {
33028 PyThreadState* __tstate = wxPyBeginAllowThreads();
33029 result = (bool)(arg1)->Destroy(arg2);
33030
33031 wxPyEndAllowThreads(__tstate);
33032 if (PyErr_Occurred()) SWIG_fail;
33033 }
33034 {
33035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33036 }
33037 return resultobj;
33038 fail:
33039 return NULL;
33040 }
33041
33042
33043 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33044 PyObject *resultobj;
33045 wxMenu *arg1 = (wxMenu *) 0 ;
33046 size_t result;
33047 PyObject * obj0 = 0 ;
33048 char *kwnames[] = {
33049 (char *) "self", NULL
33050 };
33051
33052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33054 if (SWIG_arg_fail(1)) SWIG_fail;
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33058
33059 wxPyEndAllowThreads(__tstate);
33060 if (PyErr_Occurred()) SWIG_fail;
33061 }
33062 {
33063 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33064 }
33065 return resultobj;
33066 fail:
33067 return NULL;
33068 }
33069
33070
33071 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33072 PyObject *resultobj;
33073 wxMenu *arg1 = (wxMenu *) 0 ;
33074 PyObject *result;
33075 PyObject * obj0 = 0 ;
33076 char *kwnames[] = {
33077 (char *) "self", NULL
33078 };
33079
33080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33082 if (SWIG_arg_fail(1)) SWIG_fail;
33083 {
33084 PyThreadState* __tstate = wxPyBeginAllowThreads();
33085 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33086
33087 wxPyEndAllowThreads(__tstate);
33088 if (PyErr_Occurred()) SWIG_fail;
33089 }
33090 resultobj = result;
33091 return resultobj;
33092 fail:
33093 return NULL;
33094 }
33095
33096
33097 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33098 PyObject *resultobj;
33099 wxMenu *arg1 = (wxMenu *) 0 ;
33100 wxString *arg2 = 0 ;
33101 int result;
33102 bool temp2 = false ;
33103 PyObject * obj0 = 0 ;
33104 PyObject * obj1 = 0 ;
33105 char *kwnames[] = {
33106 (char *) "self",(char *) "item", NULL
33107 };
33108
33109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33111 if (SWIG_arg_fail(1)) SWIG_fail;
33112 {
33113 arg2 = wxString_in_helper(obj1);
33114 if (arg2 == NULL) SWIG_fail;
33115 temp2 = true;
33116 }
33117 {
33118 PyThreadState* __tstate = wxPyBeginAllowThreads();
33119 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33120
33121 wxPyEndAllowThreads(__tstate);
33122 if (PyErr_Occurred()) SWIG_fail;
33123 }
33124 {
33125 resultobj = SWIG_From_int((int)(result));
33126 }
33127 {
33128 if (temp2)
33129 delete arg2;
33130 }
33131 return resultobj;
33132 fail:
33133 {
33134 if (temp2)
33135 delete arg2;
33136 }
33137 return NULL;
33138 }
33139
33140
33141 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33142 PyObject *resultobj;
33143 wxMenu *arg1 = (wxMenu *) 0 ;
33144 int arg2 ;
33145 wxMenuItem *result;
33146 PyObject * obj0 = 0 ;
33147 PyObject * obj1 = 0 ;
33148 char *kwnames[] = {
33149 (char *) "self",(char *) "id", NULL
33150 };
33151
33152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33154 if (SWIG_arg_fail(1)) SWIG_fail;
33155 {
33156 arg2 = (int)(SWIG_As_int(obj1));
33157 if (SWIG_arg_fail(2)) SWIG_fail;
33158 }
33159 {
33160 PyThreadState* __tstate = wxPyBeginAllowThreads();
33161 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33162
33163 wxPyEndAllowThreads(__tstate);
33164 if (PyErr_Occurred()) SWIG_fail;
33165 }
33166 {
33167 resultobj = wxPyMake_wxObject(result, 0);
33168 }
33169 return resultobj;
33170 fail:
33171 return NULL;
33172 }
33173
33174
33175 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33176 PyObject *resultobj;
33177 wxMenu *arg1 = (wxMenu *) 0 ;
33178 size_t arg2 ;
33179 wxMenuItem *result;
33180 PyObject * obj0 = 0 ;
33181 PyObject * obj1 = 0 ;
33182 char *kwnames[] = {
33183 (char *) "self",(char *) "position", NULL
33184 };
33185
33186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33188 if (SWIG_arg_fail(1)) SWIG_fail;
33189 {
33190 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33191 if (SWIG_arg_fail(2)) SWIG_fail;
33192 }
33193 {
33194 PyThreadState* __tstate = wxPyBeginAllowThreads();
33195 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33196
33197 wxPyEndAllowThreads(__tstate);
33198 if (PyErr_Occurred()) SWIG_fail;
33199 }
33200 {
33201 resultobj = wxPyMake_wxObject(result, 0);
33202 }
33203 return resultobj;
33204 fail:
33205 return NULL;
33206 }
33207
33208
33209 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33210 PyObject *resultobj;
33211 wxMenu *arg1 = (wxMenu *) 0 ;
33212 int arg2 ;
33213 bool arg3 ;
33214 PyObject * obj0 = 0 ;
33215 PyObject * obj1 = 0 ;
33216 PyObject * obj2 = 0 ;
33217 char *kwnames[] = {
33218 (char *) "self",(char *) "id",(char *) "enable", NULL
33219 };
33220
33221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33223 if (SWIG_arg_fail(1)) SWIG_fail;
33224 {
33225 arg2 = (int)(SWIG_As_int(obj1));
33226 if (SWIG_arg_fail(2)) SWIG_fail;
33227 }
33228 {
33229 arg3 = (bool)(SWIG_As_bool(obj2));
33230 if (SWIG_arg_fail(3)) SWIG_fail;
33231 }
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 (arg1)->Enable(arg2,arg3);
33235
33236 wxPyEndAllowThreads(__tstate);
33237 if (PyErr_Occurred()) SWIG_fail;
33238 }
33239 Py_INCREF(Py_None); resultobj = Py_None;
33240 return resultobj;
33241 fail:
33242 return NULL;
33243 }
33244
33245
33246 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33247 PyObject *resultobj;
33248 wxMenu *arg1 = (wxMenu *) 0 ;
33249 int arg2 ;
33250 bool result;
33251 PyObject * obj0 = 0 ;
33252 PyObject * obj1 = 0 ;
33253 char *kwnames[] = {
33254 (char *) "self",(char *) "id", NULL
33255 };
33256
33257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33259 if (SWIG_arg_fail(1)) SWIG_fail;
33260 {
33261 arg2 = (int)(SWIG_As_int(obj1));
33262 if (SWIG_arg_fail(2)) SWIG_fail;
33263 }
33264 {
33265 PyThreadState* __tstate = wxPyBeginAllowThreads();
33266 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33267
33268 wxPyEndAllowThreads(__tstate);
33269 if (PyErr_Occurred()) SWIG_fail;
33270 }
33271 {
33272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33273 }
33274 return resultobj;
33275 fail:
33276 return NULL;
33277 }
33278
33279
33280 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33281 PyObject *resultobj;
33282 wxMenu *arg1 = (wxMenu *) 0 ;
33283 int arg2 ;
33284 bool arg3 ;
33285 PyObject * obj0 = 0 ;
33286 PyObject * obj1 = 0 ;
33287 PyObject * obj2 = 0 ;
33288 char *kwnames[] = {
33289 (char *) "self",(char *) "id",(char *) "check", NULL
33290 };
33291
33292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33294 if (SWIG_arg_fail(1)) SWIG_fail;
33295 {
33296 arg2 = (int)(SWIG_As_int(obj1));
33297 if (SWIG_arg_fail(2)) SWIG_fail;
33298 }
33299 {
33300 arg3 = (bool)(SWIG_As_bool(obj2));
33301 if (SWIG_arg_fail(3)) SWIG_fail;
33302 }
33303 {
33304 PyThreadState* __tstate = wxPyBeginAllowThreads();
33305 (arg1)->Check(arg2,arg3);
33306
33307 wxPyEndAllowThreads(__tstate);
33308 if (PyErr_Occurred()) SWIG_fail;
33309 }
33310 Py_INCREF(Py_None); resultobj = Py_None;
33311 return resultobj;
33312 fail:
33313 return NULL;
33314 }
33315
33316
33317 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33318 PyObject *resultobj;
33319 wxMenu *arg1 = (wxMenu *) 0 ;
33320 int arg2 ;
33321 bool result;
33322 PyObject * obj0 = 0 ;
33323 PyObject * obj1 = 0 ;
33324 char *kwnames[] = {
33325 (char *) "self",(char *) "id", NULL
33326 };
33327
33328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33330 if (SWIG_arg_fail(1)) SWIG_fail;
33331 {
33332 arg2 = (int)(SWIG_As_int(obj1));
33333 if (SWIG_arg_fail(2)) SWIG_fail;
33334 }
33335 {
33336 PyThreadState* __tstate = wxPyBeginAllowThreads();
33337 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33338
33339 wxPyEndAllowThreads(__tstate);
33340 if (PyErr_Occurred()) SWIG_fail;
33341 }
33342 {
33343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33344 }
33345 return resultobj;
33346 fail:
33347 return NULL;
33348 }
33349
33350
33351 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33352 PyObject *resultobj;
33353 wxMenu *arg1 = (wxMenu *) 0 ;
33354 int arg2 ;
33355 wxString *arg3 = 0 ;
33356 bool temp3 = false ;
33357 PyObject * obj0 = 0 ;
33358 PyObject * obj1 = 0 ;
33359 PyObject * obj2 = 0 ;
33360 char *kwnames[] = {
33361 (char *) "self",(char *) "id",(char *) "label", NULL
33362 };
33363
33364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33366 if (SWIG_arg_fail(1)) SWIG_fail;
33367 {
33368 arg2 = (int)(SWIG_As_int(obj1));
33369 if (SWIG_arg_fail(2)) SWIG_fail;
33370 }
33371 {
33372 arg3 = wxString_in_helper(obj2);
33373 if (arg3 == NULL) SWIG_fail;
33374 temp3 = true;
33375 }
33376 {
33377 PyThreadState* __tstate = wxPyBeginAllowThreads();
33378 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33379
33380 wxPyEndAllowThreads(__tstate);
33381 if (PyErr_Occurred()) SWIG_fail;
33382 }
33383 Py_INCREF(Py_None); resultobj = Py_None;
33384 {
33385 if (temp3)
33386 delete arg3;
33387 }
33388 return resultobj;
33389 fail:
33390 {
33391 if (temp3)
33392 delete arg3;
33393 }
33394 return NULL;
33395 }
33396
33397
33398 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33399 PyObject *resultobj;
33400 wxMenu *arg1 = (wxMenu *) 0 ;
33401 int arg2 ;
33402 wxString result;
33403 PyObject * obj0 = 0 ;
33404 PyObject * obj1 = 0 ;
33405 char *kwnames[] = {
33406 (char *) "self",(char *) "id", NULL
33407 };
33408
33409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33411 if (SWIG_arg_fail(1)) SWIG_fail;
33412 {
33413 arg2 = (int)(SWIG_As_int(obj1));
33414 if (SWIG_arg_fail(2)) SWIG_fail;
33415 }
33416 {
33417 PyThreadState* __tstate = wxPyBeginAllowThreads();
33418 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33419
33420 wxPyEndAllowThreads(__tstate);
33421 if (PyErr_Occurred()) SWIG_fail;
33422 }
33423 {
33424 #if wxUSE_UNICODE
33425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33426 #else
33427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33428 #endif
33429 }
33430 return resultobj;
33431 fail:
33432 return NULL;
33433 }
33434
33435
33436 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33437 PyObject *resultobj;
33438 wxMenu *arg1 = (wxMenu *) 0 ;
33439 int arg2 ;
33440 wxString *arg3 = 0 ;
33441 bool temp3 = false ;
33442 PyObject * obj0 = 0 ;
33443 PyObject * obj1 = 0 ;
33444 PyObject * obj2 = 0 ;
33445 char *kwnames[] = {
33446 (char *) "self",(char *) "id",(char *) "helpString", NULL
33447 };
33448
33449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33451 if (SWIG_arg_fail(1)) SWIG_fail;
33452 {
33453 arg2 = (int)(SWIG_As_int(obj1));
33454 if (SWIG_arg_fail(2)) SWIG_fail;
33455 }
33456 {
33457 arg3 = wxString_in_helper(obj2);
33458 if (arg3 == NULL) SWIG_fail;
33459 temp3 = true;
33460 }
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33464
33465 wxPyEndAllowThreads(__tstate);
33466 if (PyErr_Occurred()) SWIG_fail;
33467 }
33468 Py_INCREF(Py_None); resultobj = Py_None;
33469 {
33470 if (temp3)
33471 delete arg3;
33472 }
33473 return resultobj;
33474 fail:
33475 {
33476 if (temp3)
33477 delete arg3;
33478 }
33479 return NULL;
33480 }
33481
33482
33483 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33484 PyObject *resultobj;
33485 wxMenu *arg1 = (wxMenu *) 0 ;
33486 int arg2 ;
33487 wxString result;
33488 PyObject * obj0 = 0 ;
33489 PyObject * obj1 = 0 ;
33490 char *kwnames[] = {
33491 (char *) "self",(char *) "id", NULL
33492 };
33493
33494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33496 if (SWIG_arg_fail(1)) SWIG_fail;
33497 {
33498 arg2 = (int)(SWIG_As_int(obj1));
33499 if (SWIG_arg_fail(2)) SWIG_fail;
33500 }
33501 {
33502 PyThreadState* __tstate = wxPyBeginAllowThreads();
33503 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33504
33505 wxPyEndAllowThreads(__tstate);
33506 if (PyErr_Occurred()) SWIG_fail;
33507 }
33508 {
33509 #if wxUSE_UNICODE
33510 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33511 #else
33512 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33513 #endif
33514 }
33515 return resultobj;
33516 fail:
33517 return NULL;
33518 }
33519
33520
33521 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33522 PyObject *resultobj;
33523 wxMenu *arg1 = (wxMenu *) 0 ;
33524 wxString *arg2 = 0 ;
33525 bool temp2 = false ;
33526 PyObject * obj0 = 0 ;
33527 PyObject * obj1 = 0 ;
33528 char *kwnames[] = {
33529 (char *) "self",(char *) "title", NULL
33530 };
33531
33532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33534 if (SWIG_arg_fail(1)) SWIG_fail;
33535 {
33536 arg2 = wxString_in_helper(obj1);
33537 if (arg2 == NULL) SWIG_fail;
33538 temp2 = true;
33539 }
33540 {
33541 PyThreadState* __tstate = wxPyBeginAllowThreads();
33542 (arg1)->SetTitle((wxString const &)*arg2);
33543
33544 wxPyEndAllowThreads(__tstate);
33545 if (PyErr_Occurred()) SWIG_fail;
33546 }
33547 Py_INCREF(Py_None); resultobj = Py_None;
33548 {
33549 if (temp2)
33550 delete arg2;
33551 }
33552 return resultobj;
33553 fail:
33554 {
33555 if (temp2)
33556 delete arg2;
33557 }
33558 return NULL;
33559 }
33560
33561
33562 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33563 PyObject *resultobj;
33564 wxMenu *arg1 = (wxMenu *) 0 ;
33565 wxString result;
33566 PyObject * obj0 = 0 ;
33567 char *kwnames[] = {
33568 (char *) "self", NULL
33569 };
33570
33571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33573 if (SWIG_arg_fail(1)) SWIG_fail;
33574 {
33575 PyThreadState* __tstate = wxPyBeginAllowThreads();
33576 result = ((wxMenu const *)arg1)->GetTitle();
33577
33578 wxPyEndAllowThreads(__tstate);
33579 if (PyErr_Occurred()) SWIG_fail;
33580 }
33581 {
33582 #if wxUSE_UNICODE
33583 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33584 #else
33585 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33586 #endif
33587 }
33588 return resultobj;
33589 fail:
33590 return NULL;
33591 }
33592
33593
33594 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33595 PyObject *resultobj;
33596 wxMenu *arg1 = (wxMenu *) 0 ;
33597 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33598 PyObject * obj0 = 0 ;
33599 PyObject * obj1 = 0 ;
33600 char *kwnames[] = {
33601 (char *) "self",(char *) "handler", NULL
33602 };
33603
33604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33606 if (SWIG_arg_fail(1)) SWIG_fail;
33607 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33608 if (SWIG_arg_fail(2)) SWIG_fail;
33609 {
33610 PyThreadState* __tstate = wxPyBeginAllowThreads();
33611 (arg1)->SetEventHandler(arg2);
33612
33613 wxPyEndAllowThreads(__tstate);
33614 if (PyErr_Occurred()) SWIG_fail;
33615 }
33616 Py_INCREF(Py_None); resultobj = Py_None;
33617 return resultobj;
33618 fail:
33619 return NULL;
33620 }
33621
33622
33623 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33624 PyObject *resultobj;
33625 wxMenu *arg1 = (wxMenu *) 0 ;
33626 wxEvtHandler *result;
33627 PyObject * obj0 = 0 ;
33628 char *kwnames[] = {
33629 (char *) "self", NULL
33630 };
33631
33632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
33633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33634 if (SWIG_arg_fail(1)) SWIG_fail;
33635 {
33636 PyThreadState* __tstate = wxPyBeginAllowThreads();
33637 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
33638
33639 wxPyEndAllowThreads(__tstate);
33640 if (PyErr_Occurred()) SWIG_fail;
33641 }
33642 {
33643 resultobj = wxPyMake_wxObject(result, 0);
33644 }
33645 return resultobj;
33646 fail:
33647 return NULL;
33648 }
33649
33650
33651 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33652 PyObject *resultobj;
33653 wxMenu *arg1 = (wxMenu *) 0 ;
33654 wxWindow *arg2 = (wxWindow *) 0 ;
33655 PyObject * obj0 = 0 ;
33656 PyObject * obj1 = 0 ;
33657 char *kwnames[] = {
33658 (char *) "self",(char *) "win", NULL
33659 };
33660
33661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
33662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33663 if (SWIG_arg_fail(1)) SWIG_fail;
33664 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33665 if (SWIG_arg_fail(2)) SWIG_fail;
33666 {
33667 PyThreadState* __tstate = wxPyBeginAllowThreads();
33668 (arg1)->SetInvokingWindow(arg2);
33669
33670 wxPyEndAllowThreads(__tstate);
33671 if (PyErr_Occurred()) SWIG_fail;
33672 }
33673 Py_INCREF(Py_None); resultobj = Py_None;
33674 return resultobj;
33675 fail:
33676 return NULL;
33677 }
33678
33679
33680 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33681 PyObject *resultobj;
33682 wxMenu *arg1 = (wxMenu *) 0 ;
33683 wxWindow *result;
33684 PyObject * obj0 = 0 ;
33685 char *kwnames[] = {
33686 (char *) "self", NULL
33687 };
33688
33689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
33690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33691 if (SWIG_arg_fail(1)) SWIG_fail;
33692 {
33693 PyThreadState* __tstate = wxPyBeginAllowThreads();
33694 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
33695
33696 wxPyEndAllowThreads(__tstate);
33697 if (PyErr_Occurred()) SWIG_fail;
33698 }
33699 {
33700 resultobj = wxPyMake_wxObject(result, 0);
33701 }
33702 return resultobj;
33703 fail:
33704 return NULL;
33705 }
33706
33707
33708 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
33709 PyObject *resultobj;
33710 wxMenu *arg1 = (wxMenu *) 0 ;
33711 long result;
33712 PyObject * obj0 = 0 ;
33713 char *kwnames[] = {
33714 (char *) "self", NULL
33715 };
33716
33717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
33718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33719 if (SWIG_arg_fail(1)) SWIG_fail;
33720 {
33721 PyThreadState* __tstate = wxPyBeginAllowThreads();
33722 result = (long)((wxMenu const *)arg1)->GetStyle();
33723
33724 wxPyEndAllowThreads(__tstate);
33725 if (PyErr_Occurred()) SWIG_fail;
33726 }
33727 {
33728 resultobj = SWIG_From_long((long)(result));
33729 }
33730 return resultobj;
33731 fail:
33732 return NULL;
33733 }
33734
33735
33736 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
33737 PyObject *resultobj;
33738 wxMenu *arg1 = (wxMenu *) 0 ;
33739 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
33740 PyObject * obj0 = 0 ;
33741 PyObject * obj1 = 0 ;
33742 char *kwnames[] = {
33743 (char *) "self",(char *) "source", NULL
33744 };
33745
33746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
33747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33748 if (SWIG_arg_fail(1)) SWIG_fail;
33749 if (obj1) {
33750 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33751 if (SWIG_arg_fail(2)) SWIG_fail;
33752 }
33753 {
33754 PyThreadState* __tstate = wxPyBeginAllowThreads();
33755 (arg1)->UpdateUI(arg2);
33756
33757 wxPyEndAllowThreads(__tstate);
33758 if (PyErr_Occurred()) SWIG_fail;
33759 }
33760 Py_INCREF(Py_None); resultobj = Py_None;
33761 return resultobj;
33762 fail:
33763 return NULL;
33764 }
33765
33766
33767 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
33768 PyObject *resultobj;
33769 wxMenu *arg1 = (wxMenu *) 0 ;
33770 wxMenuBar *result;
33771 PyObject * obj0 = 0 ;
33772 char *kwnames[] = {
33773 (char *) "self", NULL
33774 };
33775
33776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
33777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33778 if (SWIG_arg_fail(1)) SWIG_fail;
33779 {
33780 PyThreadState* __tstate = wxPyBeginAllowThreads();
33781 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
33782
33783 wxPyEndAllowThreads(__tstate);
33784 if (PyErr_Occurred()) SWIG_fail;
33785 }
33786 {
33787 resultobj = wxPyMake_wxObject(result, 0);
33788 }
33789 return resultobj;
33790 fail:
33791 return NULL;
33792 }
33793
33794
33795 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
33796 PyObject *resultobj;
33797 wxMenu *arg1 = (wxMenu *) 0 ;
33798 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
33799 PyObject * obj0 = 0 ;
33800 PyObject * obj1 = 0 ;
33801 char *kwnames[] = {
33802 (char *) "self",(char *) "menubar", NULL
33803 };
33804
33805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
33806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33807 if (SWIG_arg_fail(1)) SWIG_fail;
33808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
33809 if (SWIG_arg_fail(2)) SWIG_fail;
33810 {
33811 PyThreadState* __tstate = wxPyBeginAllowThreads();
33812 (arg1)->Attach(arg2);
33813
33814 wxPyEndAllowThreads(__tstate);
33815 if (PyErr_Occurred()) SWIG_fail;
33816 }
33817 Py_INCREF(Py_None); resultobj = Py_None;
33818 return resultobj;
33819 fail:
33820 return NULL;
33821 }
33822
33823
33824 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
33825 PyObject *resultobj;
33826 wxMenu *arg1 = (wxMenu *) 0 ;
33827 PyObject * obj0 = 0 ;
33828 char *kwnames[] = {
33829 (char *) "self", NULL
33830 };
33831
33832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
33833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33834 if (SWIG_arg_fail(1)) SWIG_fail;
33835 {
33836 PyThreadState* __tstate = wxPyBeginAllowThreads();
33837 (arg1)->Detach();
33838
33839 wxPyEndAllowThreads(__tstate);
33840 if (PyErr_Occurred()) SWIG_fail;
33841 }
33842 Py_INCREF(Py_None); resultobj = Py_None;
33843 return resultobj;
33844 fail:
33845 return NULL;
33846 }
33847
33848
33849 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
33850 PyObject *resultobj;
33851 wxMenu *arg1 = (wxMenu *) 0 ;
33852 bool result;
33853 PyObject * obj0 = 0 ;
33854 char *kwnames[] = {
33855 (char *) "self", NULL
33856 };
33857
33858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
33859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33860 if (SWIG_arg_fail(1)) SWIG_fail;
33861 {
33862 PyThreadState* __tstate = wxPyBeginAllowThreads();
33863 result = (bool)((wxMenu const *)arg1)->IsAttached();
33864
33865 wxPyEndAllowThreads(__tstate);
33866 if (PyErr_Occurred()) SWIG_fail;
33867 }
33868 {
33869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33870 }
33871 return resultobj;
33872 fail:
33873 return NULL;
33874 }
33875
33876
33877 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
33878 PyObject *resultobj;
33879 wxMenu *arg1 = (wxMenu *) 0 ;
33880 wxMenu *arg2 = (wxMenu *) 0 ;
33881 PyObject * obj0 = 0 ;
33882 PyObject * obj1 = 0 ;
33883 char *kwnames[] = {
33884 (char *) "self",(char *) "parent", NULL
33885 };
33886
33887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
33888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33889 if (SWIG_arg_fail(1)) SWIG_fail;
33890 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33891 if (SWIG_arg_fail(2)) SWIG_fail;
33892 {
33893 PyThreadState* __tstate = wxPyBeginAllowThreads();
33894 (arg1)->SetParent(arg2);
33895
33896 wxPyEndAllowThreads(__tstate);
33897 if (PyErr_Occurred()) SWIG_fail;
33898 }
33899 Py_INCREF(Py_None); resultobj = Py_None;
33900 return resultobj;
33901 fail:
33902 return NULL;
33903 }
33904
33905
33906 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
33907 PyObject *resultobj;
33908 wxMenu *arg1 = (wxMenu *) 0 ;
33909 wxMenu *result;
33910 PyObject * obj0 = 0 ;
33911 char *kwnames[] = {
33912 (char *) "self", NULL
33913 };
33914
33915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
33916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33917 if (SWIG_arg_fail(1)) SWIG_fail;
33918 {
33919 PyThreadState* __tstate = wxPyBeginAllowThreads();
33920 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
33921
33922 wxPyEndAllowThreads(__tstate);
33923 if (PyErr_Occurred()) SWIG_fail;
33924 }
33925 {
33926 resultobj = wxPyMake_wxObject(result, 0);
33927 }
33928 return resultobj;
33929 fail:
33930 return NULL;
33931 }
33932
33933
33934 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
33935 PyObject *obj;
33936 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33937 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
33938 Py_INCREF(obj);
33939 return Py_BuildValue((char *)"");
33940 }
33941 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
33942 PyObject *resultobj;
33943 long arg1 = (long) 0 ;
33944 wxMenuBar *result;
33945 PyObject * obj0 = 0 ;
33946 char *kwnames[] = {
33947 (char *) "style", NULL
33948 };
33949
33950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
33951 if (obj0) {
33952 {
33953 arg1 = (long)(SWIG_As_long(obj0));
33954 if (SWIG_arg_fail(1)) SWIG_fail;
33955 }
33956 }
33957 {
33958 if (!wxPyCheckForApp()) SWIG_fail;
33959 PyThreadState* __tstate = wxPyBeginAllowThreads();
33960 result = (wxMenuBar *)new wxMenuBar(arg1);
33961
33962 wxPyEndAllowThreads(__tstate);
33963 if (PyErr_Occurred()) SWIG_fail;
33964 }
33965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
33966 return resultobj;
33967 fail:
33968 return NULL;
33969 }
33970
33971
33972 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33973 PyObject *resultobj;
33974 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
33975 wxMenu *arg2 = (wxMenu *) 0 ;
33976 wxString *arg3 = 0 ;
33977 bool result;
33978 bool temp3 = false ;
33979 PyObject * obj0 = 0 ;
33980 PyObject * obj1 = 0 ;
33981 PyObject * obj2 = 0 ;
33982 char *kwnames[] = {
33983 (char *) "self",(char *) "menu",(char *) "title", NULL
33984 };
33985
33986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
33987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
33988 if (SWIG_arg_fail(1)) SWIG_fail;
33989 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33990 if (SWIG_arg_fail(2)) SWIG_fail;
33991 {
33992 arg3 = wxString_in_helper(obj2);
33993 if (arg3 == NULL) SWIG_fail;
33994 temp3 = true;
33995 }
33996 {
33997 PyThreadState* __tstate = wxPyBeginAllowThreads();
33998 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
33999
34000 wxPyEndAllowThreads(__tstate);
34001 if (PyErr_Occurred()) SWIG_fail;
34002 }
34003 {
34004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34005 }
34006 {
34007 if (temp3)
34008 delete arg3;
34009 }
34010 return resultobj;
34011 fail:
34012 {
34013 if (temp3)
34014 delete arg3;
34015 }
34016 return NULL;
34017 }
34018
34019
34020 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34021 PyObject *resultobj;
34022 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34023 size_t arg2 ;
34024 wxMenu *arg3 = (wxMenu *) 0 ;
34025 wxString *arg4 = 0 ;
34026 bool result;
34027 bool temp4 = false ;
34028 PyObject * obj0 = 0 ;
34029 PyObject * obj1 = 0 ;
34030 PyObject * obj2 = 0 ;
34031 PyObject * obj3 = 0 ;
34032 char *kwnames[] = {
34033 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34034 };
34035
34036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34038 if (SWIG_arg_fail(1)) SWIG_fail;
34039 {
34040 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34041 if (SWIG_arg_fail(2)) SWIG_fail;
34042 }
34043 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34044 if (SWIG_arg_fail(3)) SWIG_fail;
34045 {
34046 arg4 = wxString_in_helper(obj3);
34047 if (arg4 == NULL) SWIG_fail;
34048 temp4 = true;
34049 }
34050 {
34051 PyThreadState* __tstate = wxPyBeginAllowThreads();
34052 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34053
34054 wxPyEndAllowThreads(__tstate);
34055 if (PyErr_Occurred()) SWIG_fail;
34056 }
34057 {
34058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34059 }
34060 {
34061 if (temp4)
34062 delete arg4;
34063 }
34064 return resultobj;
34065 fail:
34066 {
34067 if (temp4)
34068 delete arg4;
34069 }
34070 return NULL;
34071 }
34072
34073
34074 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34075 PyObject *resultobj;
34076 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34077 size_t result;
34078 PyObject * obj0 = 0 ;
34079 char *kwnames[] = {
34080 (char *) "self", NULL
34081 };
34082
34083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34085 if (SWIG_arg_fail(1)) SWIG_fail;
34086 {
34087 PyThreadState* __tstate = wxPyBeginAllowThreads();
34088 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34089
34090 wxPyEndAllowThreads(__tstate);
34091 if (PyErr_Occurred()) SWIG_fail;
34092 }
34093 {
34094 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34095 }
34096 return resultobj;
34097 fail:
34098 return NULL;
34099 }
34100
34101
34102 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34103 PyObject *resultobj;
34104 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34105 size_t arg2 ;
34106 wxMenu *result;
34107 PyObject * obj0 = 0 ;
34108 PyObject * obj1 = 0 ;
34109 char *kwnames[] = {
34110 (char *) "self",(char *) "pos", NULL
34111 };
34112
34113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34115 if (SWIG_arg_fail(1)) SWIG_fail;
34116 {
34117 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34118 if (SWIG_arg_fail(2)) SWIG_fail;
34119 }
34120 {
34121 PyThreadState* __tstate = wxPyBeginAllowThreads();
34122 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34123
34124 wxPyEndAllowThreads(__tstate);
34125 if (PyErr_Occurred()) SWIG_fail;
34126 }
34127 {
34128 resultobj = wxPyMake_wxObject(result, 0);
34129 }
34130 return resultobj;
34131 fail:
34132 return NULL;
34133 }
34134
34135
34136 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34137 PyObject *resultobj;
34138 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34139 size_t arg2 ;
34140 wxMenu *arg3 = (wxMenu *) 0 ;
34141 wxString *arg4 = 0 ;
34142 wxMenu *result;
34143 bool temp4 = false ;
34144 PyObject * obj0 = 0 ;
34145 PyObject * obj1 = 0 ;
34146 PyObject * obj2 = 0 ;
34147 PyObject * obj3 = 0 ;
34148 char *kwnames[] = {
34149 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34150 };
34151
34152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34154 if (SWIG_arg_fail(1)) SWIG_fail;
34155 {
34156 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34157 if (SWIG_arg_fail(2)) SWIG_fail;
34158 }
34159 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34160 if (SWIG_arg_fail(3)) SWIG_fail;
34161 {
34162 arg4 = wxString_in_helper(obj3);
34163 if (arg4 == NULL) SWIG_fail;
34164 temp4 = true;
34165 }
34166 {
34167 PyThreadState* __tstate = wxPyBeginAllowThreads();
34168 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34169
34170 wxPyEndAllowThreads(__tstate);
34171 if (PyErr_Occurred()) SWIG_fail;
34172 }
34173 {
34174 resultobj = wxPyMake_wxObject(result, 0);
34175 }
34176 {
34177 if (temp4)
34178 delete arg4;
34179 }
34180 return resultobj;
34181 fail:
34182 {
34183 if (temp4)
34184 delete arg4;
34185 }
34186 return NULL;
34187 }
34188
34189
34190 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34191 PyObject *resultobj;
34192 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34193 size_t arg2 ;
34194 wxMenu *result;
34195 PyObject * obj0 = 0 ;
34196 PyObject * obj1 = 0 ;
34197 char *kwnames[] = {
34198 (char *) "self",(char *) "pos", NULL
34199 };
34200
34201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34203 if (SWIG_arg_fail(1)) SWIG_fail;
34204 {
34205 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34206 if (SWIG_arg_fail(2)) SWIG_fail;
34207 }
34208 {
34209 PyThreadState* __tstate = wxPyBeginAllowThreads();
34210 result = (wxMenu *)(arg1)->Remove(arg2);
34211
34212 wxPyEndAllowThreads(__tstate);
34213 if (PyErr_Occurred()) SWIG_fail;
34214 }
34215 {
34216 resultobj = wxPyMake_wxObject(result, 0);
34217 }
34218 return resultobj;
34219 fail:
34220 return NULL;
34221 }
34222
34223
34224 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34225 PyObject *resultobj;
34226 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34227 size_t arg2 ;
34228 bool arg3 ;
34229 PyObject * obj0 = 0 ;
34230 PyObject * obj1 = 0 ;
34231 PyObject * obj2 = 0 ;
34232 char *kwnames[] = {
34233 (char *) "self",(char *) "pos",(char *) "enable", NULL
34234 };
34235
34236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34238 if (SWIG_arg_fail(1)) SWIG_fail;
34239 {
34240 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34241 if (SWIG_arg_fail(2)) SWIG_fail;
34242 }
34243 {
34244 arg3 = (bool)(SWIG_As_bool(obj2));
34245 if (SWIG_arg_fail(3)) SWIG_fail;
34246 }
34247 {
34248 PyThreadState* __tstate = wxPyBeginAllowThreads();
34249 (arg1)->EnableTop(arg2,arg3);
34250
34251 wxPyEndAllowThreads(__tstate);
34252 if (PyErr_Occurred()) SWIG_fail;
34253 }
34254 Py_INCREF(Py_None); resultobj = Py_None;
34255 return resultobj;
34256 fail:
34257 return NULL;
34258 }
34259
34260
34261 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34262 PyObject *resultobj;
34263 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34264 size_t arg2 ;
34265 bool result;
34266 PyObject * obj0 = 0 ;
34267 PyObject * obj1 = 0 ;
34268 char *kwnames[] = {
34269 (char *) "self",(char *) "pos", NULL
34270 };
34271
34272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34274 if (SWIG_arg_fail(1)) SWIG_fail;
34275 {
34276 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34277 if (SWIG_arg_fail(2)) SWIG_fail;
34278 }
34279 {
34280 PyThreadState* __tstate = wxPyBeginAllowThreads();
34281 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34282
34283 wxPyEndAllowThreads(__tstate);
34284 if (PyErr_Occurred()) SWIG_fail;
34285 }
34286 {
34287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34288 }
34289 return resultobj;
34290 fail:
34291 return NULL;
34292 }
34293
34294
34295 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34296 PyObject *resultobj;
34297 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34298 size_t arg2 ;
34299 wxString *arg3 = 0 ;
34300 bool temp3 = false ;
34301 PyObject * obj0 = 0 ;
34302 PyObject * obj1 = 0 ;
34303 PyObject * obj2 = 0 ;
34304 char *kwnames[] = {
34305 (char *) "self",(char *) "pos",(char *) "label", NULL
34306 };
34307
34308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34310 if (SWIG_arg_fail(1)) SWIG_fail;
34311 {
34312 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34313 if (SWIG_arg_fail(2)) SWIG_fail;
34314 }
34315 {
34316 arg3 = wxString_in_helper(obj2);
34317 if (arg3 == NULL) SWIG_fail;
34318 temp3 = true;
34319 }
34320 {
34321 PyThreadState* __tstate = wxPyBeginAllowThreads();
34322 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34323
34324 wxPyEndAllowThreads(__tstate);
34325 if (PyErr_Occurred()) SWIG_fail;
34326 }
34327 Py_INCREF(Py_None); resultobj = Py_None;
34328 {
34329 if (temp3)
34330 delete arg3;
34331 }
34332 return resultobj;
34333 fail:
34334 {
34335 if (temp3)
34336 delete arg3;
34337 }
34338 return NULL;
34339 }
34340
34341
34342 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34343 PyObject *resultobj;
34344 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34345 size_t arg2 ;
34346 wxString result;
34347 PyObject * obj0 = 0 ;
34348 PyObject * obj1 = 0 ;
34349 char *kwnames[] = {
34350 (char *) "self",(char *) "pos", NULL
34351 };
34352
34353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34355 if (SWIG_arg_fail(1)) SWIG_fail;
34356 {
34357 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34358 if (SWIG_arg_fail(2)) SWIG_fail;
34359 }
34360 {
34361 PyThreadState* __tstate = wxPyBeginAllowThreads();
34362 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34363
34364 wxPyEndAllowThreads(__tstate);
34365 if (PyErr_Occurred()) SWIG_fail;
34366 }
34367 {
34368 #if wxUSE_UNICODE
34369 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34370 #else
34371 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34372 #endif
34373 }
34374 return resultobj;
34375 fail:
34376 return NULL;
34377 }
34378
34379
34380 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34381 PyObject *resultobj;
34382 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34383 wxString *arg2 = 0 ;
34384 wxString *arg3 = 0 ;
34385 int result;
34386 bool temp2 = false ;
34387 bool temp3 = false ;
34388 PyObject * obj0 = 0 ;
34389 PyObject * obj1 = 0 ;
34390 PyObject * obj2 = 0 ;
34391 char *kwnames[] = {
34392 (char *) "self",(char *) "menu",(char *) "item", NULL
34393 };
34394
34395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34397 if (SWIG_arg_fail(1)) SWIG_fail;
34398 {
34399 arg2 = wxString_in_helper(obj1);
34400 if (arg2 == NULL) SWIG_fail;
34401 temp2 = true;
34402 }
34403 {
34404 arg3 = wxString_in_helper(obj2);
34405 if (arg3 == NULL) SWIG_fail;
34406 temp3 = true;
34407 }
34408 {
34409 PyThreadState* __tstate = wxPyBeginAllowThreads();
34410 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34411
34412 wxPyEndAllowThreads(__tstate);
34413 if (PyErr_Occurred()) SWIG_fail;
34414 }
34415 {
34416 resultobj = SWIG_From_int((int)(result));
34417 }
34418 {
34419 if (temp2)
34420 delete arg2;
34421 }
34422 {
34423 if (temp3)
34424 delete arg3;
34425 }
34426 return resultobj;
34427 fail:
34428 {
34429 if (temp2)
34430 delete arg2;
34431 }
34432 {
34433 if (temp3)
34434 delete arg3;
34435 }
34436 return NULL;
34437 }
34438
34439
34440 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34441 PyObject *resultobj;
34442 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34443 int arg2 ;
34444 wxMenuItem *result;
34445 PyObject * obj0 = 0 ;
34446 PyObject * obj1 = 0 ;
34447 char *kwnames[] = {
34448 (char *) "self",(char *) "id", NULL
34449 };
34450
34451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34453 if (SWIG_arg_fail(1)) SWIG_fail;
34454 {
34455 arg2 = (int)(SWIG_As_int(obj1));
34456 if (SWIG_arg_fail(2)) SWIG_fail;
34457 }
34458 {
34459 PyThreadState* __tstate = wxPyBeginAllowThreads();
34460 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34461
34462 wxPyEndAllowThreads(__tstate);
34463 if (PyErr_Occurred()) SWIG_fail;
34464 }
34465 {
34466 resultobj = wxPyMake_wxObject(result, 0);
34467 }
34468 return resultobj;
34469 fail:
34470 return NULL;
34471 }
34472
34473
34474 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34475 PyObject *resultobj;
34476 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34477 wxString *arg2 = 0 ;
34478 int result;
34479 bool temp2 = false ;
34480 PyObject * obj0 = 0 ;
34481 PyObject * obj1 = 0 ;
34482 char *kwnames[] = {
34483 (char *) "self",(char *) "title", NULL
34484 };
34485
34486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34488 if (SWIG_arg_fail(1)) SWIG_fail;
34489 {
34490 arg2 = wxString_in_helper(obj1);
34491 if (arg2 == NULL) SWIG_fail;
34492 temp2 = true;
34493 }
34494 {
34495 PyThreadState* __tstate = wxPyBeginAllowThreads();
34496 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34497
34498 wxPyEndAllowThreads(__tstate);
34499 if (PyErr_Occurred()) SWIG_fail;
34500 }
34501 {
34502 resultobj = SWIG_From_int((int)(result));
34503 }
34504 {
34505 if (temp2)
34506 delete arg2;
34507 }
34508 return resultobj;
34509 fail:
34510 {
34511 if (temp2)
34512 delete arg2;
34513 }
34514 return NULL;
34515 }
34516
34517
34518 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34519 PyObject *resultobj;
34520 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34521 int arg2 ;
34522 bool arg3 ;
34523 PyObject * obj0 = 0 ;
34524 PyObject * obj1 = 0 ;
34525 PyObject * obj2 = 0 ;
34526 char *kwnames[] = {
34527 (char *) "self",(char *) "id",(char *) "enable", NULL
34528 };
34529
34530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34532 if (SWIG_arg_fail(1)) SWIG_fail;
34533 {
34534 arg2 = (int)(SWIG_As_int(obj1));
34535 if (SWIG_arg_fail(2)) SWIG_fail;
34536 }
34537 {
34538 arg3 = (bool)(SWIG_As_bool(obj2));
34539 if (SWIG_arg_fail(3)) SWIG_fail;
34540 }
34541 {
34542 PyThreadState* __tstate = wxPyBeginAllowThreads();
34543 (arg1)->Enable(arg2,arg3);
34544
34545 wxPyEndAllowThreads(__tstate);
34546 if (PyErr_Occurred()) SWIG_fail;
34547 }
34548 Py_INCREF(Py_None); resultobj = Py_None;
34549 return resultobj;
34550 fail:
34551 return NULL;
34552 }
34553
34554
34555 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34556 PyObject *resultobj;
34557 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34558 int arg2 ;
34559 bool arg3 ;
34560 PyObject * obj0 = 0 ;
34561 PyObject * obj1 = 0 ;
34562 PyObject * obj2 = 0 ;
34563 char *kwnames[] = {
34564 (char *) "self",(char *) "id",(char *) "check", NULL
34565 };
34566
34567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34569 if (SWIG_arg_fail(1)) SWIG_fail;
34570 {
34571 arg2 = (int)(SWIG_As_int(obj1));
34572 if (SWIG_arg_fail(2)) SWIG_fail;
34573 }
34574 {
34575 arg3 = (bool)(SWIG_As_bool(obj2));
34576 if (SWIG_arg_fail(3)) SWIG_fail;
34577 }
34578 {
34579 PyThreadState* __tstate = wxPyBeginAllowThreads();
34580 (arg1)->Check(arg2,arg3);
34581
34582 wxPyEndAllowThreads(__tstate);
34583 if (PyErr_Occurred()) SWIG_fail;
34584 }
34585 Py_INCREF(Py_None); resultobj = Py_None;
34586 return resultobj;
34587 fail:
34588 return NULL;
34589 }
34590
34591
34592 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34593 PyObject *resultobj;
34594 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34595 int arg2 ;
34596 bool result;
34597 PyObject * obj0 = 0 ;
34598 PyObject * obj1 = 0 ;
34599 char *kwnames[] = {
34600 (char *) "self",(char *) "id", NULL
34601 };
34602
34603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34605 if (SWIG_arg_fail(1)) SWIG_fail;
34606 {
34607 arg2 = (int)(SWIG_As_int(obj1));
34608 if (SWIG_arg_fail(2)) SWIG_fail;
34609 }
34610 {
34611 PyThreadState* __tstate = wxPyBeginAllowThreads();
34612 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
34613
34614 wxPyEndAllowThreads(__tstate);
34615 if (PyErr_Occurred()) SWIG_fail;
34616 }
34617 {
34618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34619 }
34620 return resultobj;
34621 fail:
34622 return NULL;
34623 }
34624
34625
34626 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34627 PyObject *resultobj;
34628 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34629 int arg2 ;
34630 bool result;
34631 PyObject * obj0 = 0 ;
34632 PyObject * obj1 = 0 ;
34633 char *kwnames[] = {
34634 (char *) "self",(char *) "id", NULL
34635 };
34636
34637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34639 if (SWIG_arg_fail(1)) SWIG_fail;
34640 {
34641 arg2 = (int)(SWIG_As_int(obj1));
34642 if (SWIG_arg_fail(2)) SWIG_fail;
34643 }
34644 {
34645 PyThreadState* __tstate = wxPyBeginAllowThreads();
34646 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
34647
34648 wxPyEndAllowThreads(__tstate);
34649 if (PyErr_Occurred()) SWIG_fail;
34650 }
34651 {
34652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34653 }
34654 return resultobj;
34655 fail:
34656 return NULL;
34657 }
34658
34659
34660 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34661 PyObject *resultobj;
34662 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34663 int arg2 ;
34664 wxString *arg3 = 0 ;
34665 bool temp3 = false ;
34666 PyObject * obj0 = 0 ;
34667 PyObject * obj1 = 0 ;
34668 PyObject * obj2 = 0 ;
34669 char *kwnames[] = {
34670 (char *) "self",(char *) "id",(char *) "label", NULL
34671 };
34672
34673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34675 if (SWIG_arg_fail(1)) SWIG_fail;
34676 {
34677 arg2 = (int)(SWIG_As_int(obj1));
34678 if (SWIG_arg_fail(2)) SWIG_fail;
34679 }
34680 {
34681 arg3 = wxString_in_helper(obj2);
34682 if (arg3 == NULL) SWIG_fail;
34683 temp3 = true;
34684 }
34685 {
34686 PyThreadState* __tstate = wxPyBeginAllowThreads();
34687 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34688
34689 wxPyEndAllowThreads(__tstate);
34690 if (PyErr_Occurred()) SWIG_fail;
34691 }
34692 Py_INCREF(Py_None); resultobj = Py_None;
34693 {
34694 if (temp3)
34695 delete arg3;
34696 }
34697 return resultobj;
34698 fail:
34699 {
34700 if (temp3)
34701 delete arg3;
34702 }
34703 return NULL;
34704 }
34705
34706
34707 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34708 PyObject *resultobj;
34709 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34710 int arg2 ;
34711 wxString result;
34712 PyObject * obj0 = 0 ;
34713 PyObject * obj1 = 0 ;
34714 char *kwnames[] = {
34715 (char *) "self",(char *) "id", NULL
34716 };
34717
34718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34720 if (SWIG_arg_fail(1)) SWIG_fail;
34721 {
34722 arg2 = (int)(SWIG_As_int(obj1));
34723 if (SWIG_arg_fail(2)) SWIG_fail;
34724 }
34725 {
34726 PyThreadState* __tstate = wxPyBeginAllowThreads();
34727 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
34728
34729 wxPyEndAllowThreads(__tstate);
34730 if (PyErr_Occurred()) SWIG_fail;
34731 }
34732 {
34733 #if wxUSE_UNICODE
34734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34735 #else
34736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34737 #endif
34738 }
34739 return resultobj;
34740 fail:
34741 return NULL;
34742 }
34743
34744
34745 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34746 PyObject *resultobj;
34747 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34748 int arg2 ;
34749 wxString *arg3 = 0 ;
34750 bool temp3 = false ;
34751 PyObject * obj0 = 0 ;
34752 PyObject * obj1 = 0 ;
34753 PyObject * obj2 = 0 ;
34754 char *kwnames[] = {
34755 (char *) "self",(char *) "id",(char *) "helpString", NULL
34756 };
34757
34758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34760 if (SWIG_arg_fail(1)) SWIG_fail;
34761 {
34762 arg2 = (int)(SWIG_As_int(obj1));
34763 if (SWIG_arg_fail(2)) SWIG_fail;
34764 }
34765 {
34766 arg3 = wxString_in_helper(obj2);
34767 if (arg3 == NULL) SWIG_fail;
34768 temp3 = true;
34769 }
34770 {
34771 PyThreadState* __tstate = wxPyBeginAllowThreads();
34772 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34773
34774 wxPyEndAllowThreads(__tstate);
34775 if (PyErr_Occurred()) SWIG_fail;
34776 }
34777 Py_INCREF(Py_None); resultobj = Py_None;
34778 {
34779 if (temp3)
34780 delete arg3;
34781 }
34782 return resultobj;
34783 fail:
34784 {
34785 if (temp3)
34786 delete arg3;
34787 }
34788 return NULL;
34789 }
34790
34791
34792 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34793 PyObject *resultobj;
34794 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34795 int arg2 ;
34796 wxString result;
34797 PyObject * obj0 = 0 ;
34798 PyObject * obj1 = 0 ;
34799 char *kwnames[] = {
34800 (char *) "self",(char *) "id", NULL
34801 };
34802
34803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34805 if (SWIG_arg_fail(1)) SWIG_fail;
34806 {
34807 arg2 = (int)(SWIG_As_int(obj1));
34808 if (SWIG_arg_fail(2)) SWIG_fail;
34809 }
34810 {
34811 PyThreadState* __tstate = wxPyBeginAllowThreads();
34812 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
34813
34814 wxPyEndAllowThreads(__tstate);
34815 if (PyErr_Occurred()) SWIG_fail;
34816 }
34817 {
34818 #if wxUSE_UNICODE
34819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34820 #else
34821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34822 #endif
34823 }
34824 return resultobj;
34825 fail:
34826 return NULL;
34827 }
34828
34829
34830 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
34831 PyObject *resultobj;
34832 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34833 wxFrame *result;
34834 PyObject * obj0 = 0 ;
34835 char *kwnames[] = {
34836 (char *) "self", NULL
34837 };
34838
34839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
34840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34841 if (SWIG_arg_fail(1)) SWIG_fail;
34842 {
34843 PyThreadState* __tstate = wxPyBeginAllowThreads();
34844 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
34845
34846 wxPyEndAllowThreads(__tstate);
34847 if (PyErr_Occurred()) SWIG_fail;
34848 }
34849 {
34850 resultobj = wxPyMake_wxObject(result, 0);
34851 }
34852 return resultobj;
34853 fail:
34854 return NULL;
34855 }
34856
34857
34858 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34859 PyObject *resultobj;
34860 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34861 bool result;
34862 PyObject * obj0 = 0 ;
34863 char *kwnames[] = {
34864 (char *) "self", NULL
34865 };
34866
34867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
34868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34869 if (SWIG_arg_fail(1)) SWIG_fail;
34870 {
34871 PyThreadState* __tstate = wxPyBeginAllowThreads();
34872 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
34873
34874 wxPyEndAllowThreads(__tstate);
34875 if (PyErr_Occurred()) SWIG_fail;
34876 }
34877 {
34878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34879 }
34880 return resultobj;
34881 fail:
34882 return NULL;
34883 }
34884
34885
34886 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34887 PyObject *resultobj;
34888 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34889 wxFrame *arg2 = (wxFrame *) 0 ;
34890 PyObject * obj0 = 0 ;
34891 PyObject * obj1 = 0 ;
34892 char *kwnames[] = {
34893 (char *) "self",(char *) "frame", NULL
34894 };
34895
34896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
34897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34898 if (SWIG_arg_fail(1)) SWIG_fail;
34899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
34900 if (SWIG_arg_fail(2)) SWIG_fail;
34901 {
34902 PyThreadState* __tstate = wxPyBeginAllowThreads();
34903 (arg1)->Attach(arg2);
34904
34905 wxPyEndAllowThreads(__tstate);
34906 if (PyErr_Occurred()) SWIG_fail;
34907 }
34908 Py_INCREF(Py_None); resultobj = Py_None;
34909 return resultobj;
34910 fail:
34911 return NULL;
34912 }
34913
34914
34915 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34916 PyObject *resultobj;
34917 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34918 PyObject * obj0 = 0 ;
34919 char *kwnames[] = {
34920 (char *) "self", NULL
34921 };
34922
34923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
34924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34925 if (SWIG_arg_fail(1)) SWIG_fail;
34926 {
34927 PyThreadState* __tstate = wxPyBeginAllowThreads();
34928 (arg1)->Detach();
34929
34930 wxPyEndAllowThreads(__tstate);
34931 if (PyErr_Occurred()) SWIG_fail;
34932 }
34933 Py_INCREF(Py_None); resultobj = Py_None;
34934 return resultobj;
34935 fail:
34936 return NULL;
34937 }
34938
34939
34940 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
34941 PyObject *obj;
34942 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34943 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
34944 Py_INCREF(obj);
34945 return Py_BuildValue((char *)"");
34946 }
34947 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34948 PyObject *resultobj;
34949 wxMenu *arg1 = (wxMenu *) NULL ;
34950 int arg2 = (int) wxID_ANY ;
34951 wxString const &arg3_defvalue = wxPyEmptyString ;
34952 wxString *arg3 = (wxString *) &arg3_defvalue ;
34953 wxString const &arg4_defvalue = wxPyEmptyString ;
34954 wxString *arg4 = (wxString *) &arg4_defvalue ;
34955 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34956 wxMenu *arg6 = (wxMenu *) NULL ;
34957 wxMenuItem *result;
34958 bool temp3 = false ;
34959 bool temp4 = false ;
34960 PyObject * obj0 = 0 ;
34961 PyObject * obj1 = 0 ;
34962 PyObject * obj2 = 0 ;
34963 PyObject * obj3 = 0 ;
34964 PyObject * obj4 = 0 ;
34965 PyObject * obj5 = 0 ;
34966 char *kwnames[] = {
34967 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
34968 };
34969
34970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34971 if (obj0) {
34972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34973 if (SWIG_arg_fail(1)) SWIG_fail;
34974 }
34975 if (obj1) {
34976 {
34977 arg2 = (int)(SWIG_As_int(obj1));
34978 if (SWIG_arg_fail(2)) SWIG_fail;
34979 }
34980 }
34981 if (obj2) {
34982 {
34983 arg3 = wxString_in_helper(obj2);
34984 if (arg3 == NULL) SWIG_fail;
34985 temp3 = true;
34986 }
34987 }
34988 if (obj3) {
34989 {
34990 arg4 = wxString_in_helper(obj3);
34991 if (arg4 == NULL) SWIG_fail;
34992 temp4 = true;
34993 }
34994 }
34995 if (obj4) {
34996 {
34997 arg5 = (wxItemKind)(SWIG_As_int(obj4));
34998 if (SWIG_arg_fail(5)) SWIG_fail;
34999 }
35000 }
35001 if (obj5) {
35002 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35003 if (SWIG_arg_fail(6)) SWIG_fail;
35004 }
35005 {
35006 PyThreadState* __tstate = wxPyBeginAllowThreads();
35007 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35008
35009 wxPyEndAllowThreads(__tstate);
35010 if (PyErr_Occurred()) SWIG_fail;
35011 }
35012 {
35013 resultobj = wxPyMake_wxObject(result, 1);
35014 }
35015 {
35016 if (temp3)
35017 delete arg3;
35018 }
35019 {
35020 if (temp4)
35021 delete arg4;
35022 }
35023 return resultobj;
35024 fail:
35025 {
35026 if (temp3)
35027 delete arg3;
35028 }
35029 {
35030 if (temp4)
35031 delete arg4;
35032 }
35033 return NULL;
35034 }
35035
35036
35037 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35038 PyObject *resultobj;
35039 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35040 wxMenu *result;
35041 PyObject * obj0 = 0 ;
35042 char *kwnames[] = {
35043 (char *) "self", NULL
35044 };
35045
35046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35048 if (SWIG_arg_fail(1)) SWIG_fail;
35049 {
35050 PyThreadState* __tstate = wxPyBeginAllowThreads();
35051 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35052
35053 wxPyEndAllowThreads(__tstate);
35054 if (PyErr_Occurred()) SWIG_fail;
35055 }
35056 {
35057 resultobj = wxPyMake_wxObject(result, 0);
35058 }
35059 return resultobj;
35060 fail:
35061 return NULL;
35062 }
35063
35064
35065 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35066 PyObject *resultobj;
35067 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35068 wxMenu *arg2 = (wxMenu *) 0 ;
35069 PyObject * obj0 = 0 ;
35070 PyObject * obj1 = 0 ;
35071 char *kwnames[] = {
35072 (char *) "self",(char *) "menu", NULL
35073 };
35074
35075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35077 if (SWIG_arg_fail(1)) SWIG_fail;
35078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35079 if (SWIG_arg_fail(2)) SWIG_fail;
35080 {
35081 PyThreadState* __tstate = wxPyBeginAllowThreads();
35082 (arg1)->SetMenu(arg2);
35083
35084 wxPyEndAllowThreads(__tstate);
35085 if (PyErr_Occurred()) SWIG_fail;
35086 }
35087 Py_INCREF(Py_None); resultobj = Py_None;
35088 return resultobj;
35089 fail:
35090 return NULL;
35091 }
35092
35093
35094 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35095 PyObject *resultobj;
35096 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35097 int arg2 ;
35098 PyObject * obj0 = 0 ;
35099 PyObject * obj1 = 0 ;
35100 char *kwnames[] = {
35101 (char *) "self",(char *) "id", NULL
35102 };
35103
35104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35106 if (SWIG_arg_fail(1)) SWIG_fail;
35107 {
35108 arg2 = (int)(SWIG_As_int(obj1));
35109 if (SWIG_arg_fail(2)) SWIG_fail;
35110 }
35111 {
35112 PyThreadState* __tstate = wxPyBeginAllowThreads();
35113 (arg1)->SetId(arg2);
35114
35115 wxPyEndAllowThreads(__tstate);
35116 if (PyErr_Occurred()) SWIG_fail;
35117 }
35118 Py_INCREF(Py_None); resultobj = Py_None;
35119 return resultobj;
35120 fail:
35121 return NULL;
35122 }
35123
35124
35125 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35126 PyObject *resultobj;
35127 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35128 int result;
35129 PyObject * obj0 = 0 ;
35130 char *kwnames[] = {
35131 (char *) "self", NULL
35132 };
35133
35134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35136 if (SWIG_arg_fail(1)) SWIG_fail;
35137 {
35138 PyThreadState* __tstate = wxPyBeginAllowThreads();
35139 result = (int)((wxMenuItem const *)arg1)->GetId();
35140
35141 wxPyEndAllowThreads(__tstate);
35142 if (PyErr_Occurred()) SWIG_fail;
35143 }
35144 {
35145 resultobj = SWIG_From_int((int)(result));
35146 }
35147 return resultobj;
35148 fail:
35149 return NULL;
35150 }
35151
35152
35153 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35154 PyObject *resultobj;
35155 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35156 bool result;
35157 PyObject * obj0 = 0 ;
35158 char *kwnames[] = {
35159 (char *) "self", NULL
35160 };
35161
35162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35164 if (SWIG_arg_fail(1)) SWIG_fail;
35165 {
35166 PyThreadState* __tstate = wxPyBeginAllowThreads();
35167 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35168
35169 wxPyEndAllowThreads(__tstate);
35170 if (PyErr_Occurred()) SWIG_fail;
35171 }
35172 {
35173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35174 }
35175 return resultobj;
35176 fail:
35177 return NULL;
35178 }
35179
35180
35181 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35182 PyObject *resultobj;
35183 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35184 wxString *arg2 = 0 ;
35185 bool temp2 = false ;
35186 PyObject * obj0 = 0 ;
35187 PyObject * obj1 = 0 ;
35188 char *kwnames[] = {
35189 (char *) "self",(char *) "str", NULL
35190 };
35191
35192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35194 if (SWIG_arg_fail(1)) SWIG_fail;
35195 {
35196 arg2 = wxString_in_helper(obj1);
35197 if (arg2 == NULL) SWIG_fail;
35198 temp2 = true;
35199 }
35200 {
35201 PyThreadState* __tstate = wxPyBeginAllowThreads();
35202 (arg1)->SetText((wxString const &)*arg2);
35203
35204 wxPyEndAllowThreads(__tstate);
35205 if (PyErr_Occurred()) SWIG_fail;
35206 }
35207 Py_INCREF(Py_None); resultobj = Py_None;
35208 {
35209 if (temp2)
35210 delete arg2;
35211 }
35212 return resultobj;
35213 fail:
35214 {
35215 if (temp2)
35216 delete arg2;
35217 }
35218 return NULL;
35219 }
35220
35221
35222 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35223 PyObject *resultobj;
35224 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35225 wxString result;
35226 PyObject * obj0 = 0 ;
35227 char *kwnames[] = {
35228 (char *) "self", NULL
35229 };
35230
35231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35233 if (SWIG_arg_fail(1)) SWIG_fail;
35234 {
35235 PyThreadState* __tstate = wxPyBeginAllowThreads();
35236 result = ((wxMenuItem const *)arg1)->GetLabel();
35237
35238 wxPyEndAllowThreads(__tstate);
35239 if (PyErr_Occurred()) SWIG_fail;
35240 }
35241 {
35242 #if wxUSE_UNICODE
35243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35244 #else
35245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35246 #endif
35247 }
35248 return resultobj;
35249 fail:
35250 return NULL;
35251 }
35252
35253
35254 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35255 PyObject *resultobj;
35256 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35257 wxString *result;
35258 PyObject * obj0 = 0 ;
35259 char *kwnames[] = {
35260 (char *) "self", NULL
35261 };
35262
35263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35265 if (SWIG_arg_fail(1)) SWIG_fail;
35266 {
35267 PyThreadState* __tstate = wxPyBeginAllowThreads();
35268 {
35269 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35270 result = (wxString *) &_result_ref;
35271 }
35272
35273 wxPyEndAllowThreads(__tstate);
35274 if (PyErr_Occurred()) SWIG_fail;
35275 }
35276 {
35277 #if wxUSE_UNICODE
35278 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35279 #else
35280 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35281 #endif
35282 }
35283 return resultobj;
35284 fail:
35285 return NULL;
35286 }
35287
35288
35289 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35290 PyObject *resultobj;
35291 wxString *arg1 = 0 ;
35292 wxString result;
35293 bool temp1 = false ;
35294 PyObject * obj0 = 0 ;
35295 char *kwnames[] = {
35296 (char *) "text", NULL
35297 };
35298
35299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35300 {
35301 arg1 = wxString_in_helper(obj0);
35302 if (arg1 == NULL) SWIG_fail;
35303 temp1 = true;
35304 }
35305 {
35306 PyThreadState* __tstate = wxPyBeginAllowThreads();
35307 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35308
35309 wxPyEndAllowThreads(__tstate);
35310 if (PyErr_Occurred()) SWIG_fail;
35311 }
35312 {
35313 #if wxUSE_UNICODE
35314 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35315 #else
35316 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35317 #endif
35318 }
35319 {
35320 if (temp1)
35321 delete arg1;
35322 }
35323 return resultobj;
35324 fail:
35325 {
35326 if (temp1)
35327 delete arg1;
35328 }
35329 return NULL;
35330 }
35331
35332
35333 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35334 PyObject *resultobj;
35335 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35336 wxItemKind result;
35337 PyObject * obj0 = 0 ;
35338 char *kwnames[] = {
35339 (char *) "self", NULL
35340 };
35341
35342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35344 if (SWIG_arg_fail(1)) SWIG_fail;
35345 {
35346 PyThreadState* __tstate = wxPyBeginAllowThreads();
35347 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35348
35349 wxPyEndAllowThreads(__tstate);
35350 if (PyErr_Occurred()) SWIG_fail;
35351 }
35352 resultobj = SWIG_From_int((result));
35353 return resultobj;
35354 fail:
35355 return NULL;
35356 }
35357
35358
35359 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35360 PyObject *resultobj;
35361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35362 wxItemKind arg2 ;
35363 PyObject * obj0 = 0 ;
35364 PyObject * obj1 = 0 ;
35365 char *kwnames[] = {
35366 (char *) "self",(char *) "kind", NULL
35367 };
35368
35369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35371 if (SWIG_arg_fail(1)) SWIG_fail;
35372 {
35373 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35374 if (SWIG_arg_fail(2)) SWIG_fail;
35375 }
35376 {
35377 PyThreadState* __tstate = wxPyBeginAllowThreads();
35378 (arg1)->SetKind((wxItemKind )arg2);
35379
35380 wxPyEndAllowThreads(__tstate);
35381 if (PyErr_Occurred()) SWIG_fail;
35382 }
35383 Py_INCREF(Py_None); resultobj = Py_None;
35384 return resultobj;
35385 fail:
35386 return NULL;
35387 }
35388
35389
35390 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35391 PyObject *resultobj;
35392 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35393 bool arg2 ;
35394 PyObject * obj0 = 0 ;
35395 PyObject * obj1 = 0 ;
35396 char *kwnames[] = {
35397 (char *) "self",(char *) "checkable", NULL
35398 };
35399
35400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35402 if (SWIG_arg_fail(1)) SWIG_fail;
35403 {
35404 arg2 = (bool)(SWIG_As_bool(obj1));
35405 if (SWIG_arg_fail(2)) SWIG_fail;
35406 }
35407 {
35408 PyThreadState* __tstate = wxPyBeginAllowThreads();
35409 (arg1)->SetCheckable(arg2);
35410
35411 wxPyEndAllowThreads(__tstate);
35412 if (PyErr_Occurred()) SWIG_fail;
35413 }
35414 Py_INCREF(Py_None); resultobj = Py_None;
35415 return resultobj;
35416 fail:
35417 return NULL;
35418 }
35419
35420
35421 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35422 PyObject *resultobj;
35423 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35424 bool result;
35425 PyObject * obj0 = 0 ;
35426 char *kwnames[] = {
35427 (char *) "self", NULL
35428 };
35429
35430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35432 if (SWIG_arg_fail(1)) SWIG_fail;
35433 {
35434 PyThreadState* __tstate = wxPyBeginAllowThreads();
35435 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35436
35437 wxPyEndAllowThreads(__tstate);
35438 if (PyErr_Occurred()) SWIG_fail;
35439 }
35440 {
35441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35442 }
35443 return resultobj;
35444 fail:
35445 return NULL;
35446 }
35447
35448
35449 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35450 PyObject *resultobj;
35451 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35452 bool result;
35453 PyObject * obj0 = 0 ;
35454 char *kwnames[] = {
35455 (char *) "self", NULL
35456 };
35457
35458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35460 if (SWIG_arg_fail(1)) SWIG_fail;
35461 {
35462 PyThreadState* __tstate = wxPyBeginAllowThreads();
35463 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35464
35465 wxPyEndAllowThreads(__tstate);
35466 if (PyErr_Occurred()) SWIG_fail;
35467 }
35468 {
35469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35470 }
35471 return resultobj;
35472 fail:
35473 return NULL;
35474 }
35475
35476
35477 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35478 PyObject *resultobj;
35479 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35480 wxMenu *arg2 = (wxMenu *) 0 ;
35481 PyObject * obj0 = 0 ;
35482 PyObject * obj1 = 0 ;
35483 char *kwnames[] = {
35484 (char *) "self",(char *) "menu", NULL
35485 };
35486
35487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35489 if (SWIG_arg_fail(1)) SWIG_fail;
35490 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35491 if (SWIG_arg_fail(2)) SWIG_fail;
35492 {
35493 PyThreadState* __tstate = wxPyBeginAllowThreads();
35494 (arg1)->SetSubMenu(arg2);
35495
35496 wxPyEndAllowThreads(__tstate);
35497 if (PyErr_Occurred()) SWIG_fail;
35498 }
35499 Py_INCREF(Py_None); resultobj = Py_None;
35500 return resultobj;
35501 fail:
35502 return NULL;
35503 }
35504
35505
35506 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35507 PyObject *resultobj;
35508 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35509 wxMenu *result;
35510 PyObject * obj0 = 0 ;
35511 char *kwnames[] = {
35512 (char *) "self", NULL
35513 };
35514
35515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35517 if (SWIG_arg_fail(1)) SWIG_fail;
35518 {
35519 PyThreadState* __tstate = wxPyBeginAllowThreads();
35520 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35521
35522 wxPyEndAllowThreads(__tstate);
35523 if (PyErr_Occurred()) SWIG_fail;
35524 }
35525 {
35526 resultobj = wxPyMake_wxObject(result, 0);
35527 }
35528 return resultobj;
35529 fail:
35530 return NULL;
35531 }
35532
35533
35534 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35535 PyObject *resultobj;
35536 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35537 bool arg2 = (bool) true ;
35538 PyObject * obj0 = 0 ;
35539 PyObject * obj1 = 0 ;
35540 char *kwnames[] = {
35541 (char *) "self",(char *) "enable", NULL
35542 };
35543
35544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35546 if (SWIG_arg_fail(1)) SWIG_fail;
35547 if (obj1) {
35548 {
35549 arg2 = (bool)(SWIG_As_bool(obj1));
35550 if (SWIG_arg_fail(2)) SWIG_fail;
35551 }
35552 }
35553 {
35554 PyThreadState* __tstate = wxPyBeginAllowThreads();
35555 (arg1)->Enable(arg2);
35556
35557 wxPyEndAllowThreads(__tstate);
35558 if (PyErr_Occurred()) SWIG_fail;
35559 }
35560 Py_INCREF(Py_None); resultobj = Py_None;
35561 return resultobj;
35562 fail:
35563 return NULL;
35564 }
35565
35566
35567 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35568 PyObject *resultobj;
35569 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35570 bool result;
35571 PyObject * obj0 = 0 ;
35572 char *kwnames[] = {
35573 (char *) "self", NULL
35574 };
35575
35576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35578 if (SWIG_arg_fail(1)) SWIG_fail;
35579 {
35580 PyThreadState* __tstate = wxPyBeginAllowThreads();
35581 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35582
35583 wxPyEndAllowThreads(__tstate);
35584 if (PyErr_Occurred()) SWIG_fail;
35585 }
35586 {
35587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35588 }
35589 return resultobj;
35590 fail:
35591 return NULL;
35592 }
35593
35594
35595 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35596 PyObject *resultobj;
35597 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35598 bool arg2 = (bool) true ;
35599 PyObject * obj0 = 0 ;
35600 PyObject * obj1 = 0 ;
35601 char *kwnames[] = {
35602 (char *) "self",(char *) "check", NULL
35603 };
35604
35605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35607 if (SWIG_arg_fail(1)) SWIG_fail;
35608 if (obj1) {
35609 {
35610 arg2 = (bool)(SWIG_As_bool(obj1));
35611 if (SWIG_arg_fail(2)) SWIG_fail;
35612 }
35613 }
35614 {
35615 PyThreadState* __tstate = wxPyBeginAllowThreads();
35616 (arg1)->Check(arg2);
35617
35618 wxPyEndAllowThreads(__tstate);
35619 if (PyErr_Occurred()) SWIG_fail;
35620 }
35621 Py_INCREF(Py_None); resultobj = Py_None;
35622 return resultobj;
35623 fail:
35624 return NULL;
35625 }
35626
35627
35628 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35629 PyObject *resultobj;
35630 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35631 bool result;
35632 PyObject * obj0 = 0 ;
35633 char *kwnames[] = {
35634 (char *) "self", NULL
35635 };
35636
35637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
35638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35639 if (SWIG_arg_fail(1)) SWIG_fail;
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
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_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
35657 PyObject *resultobj;
35658 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35659 PyObject * obj0 = 0 ;
35660 char *kwnames[] = {
35661 (char *) "self", NULL
35662 };
35663
35664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
35665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35666 if (SWIG_arg_fail(1)) SWIG_fail;
35667 {
35668 PyThreadState* __tstate = wxPyBeginAllowThreads();
35669 (arg1)->Toggle();
35670
35671 wxPyEndAllowThreads(__tstate);
35672 if (PyErr_Occurred()) SWIG_fail;
35673 }
35674 Py_INCREF(Py_None); resultobj = Py_None;
35675 return resultobj;
35676 fail:
35677 return NULL;
35678 }
35679
35680
35681 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35682 PyObject *resultobj;
35683 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35684 wxString *arg2 = 0 ;
35685 bool temp2 = false ;
35686 PyObject * obj0 = 0 ;
35687 PyObject * obj1 = 0 ;
35688 char *kwnames[] = {
35689 (char *) "self",(char *) "str", NULL
35690 };
35691
35692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
35693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35694 if (SWIG_arg_fail(1)) SWIG_fail;
35695 {
35696 arg2 = wxString_in_helper(obj1);
35697 if (arg2 == NULL) SWIG_fail;
35698 temp2 = true;
35699 }
35700 {
35701 PyThreadState* __tstate = wxPyBeginAllowThreads();
35702 (arg1)->SetHelp((wxString const &)*arg2);
35703
35704 wxPyEndAllowThreads(__tstate);
35705 if (PyErr_Occurred()) SWIG_fail;
35706 }
35707 Py_INCREF(Py_None); resultobj = Py_None;
35708 {
35709 if (temp2)
35710 delete arg2;
35711 }
35712 return resultobj;
35713 fail:
35714 {
35715 if (temp2)
35716 delete arg2;
35717 }
35718 return NULL;
35719 }
35720
35721
35722 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35723 PyObject *resultobj;
35724 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35725 wxString *result;
35726 PyObject * obj0 = 0 ;
35727 char *kwnames[] = {
35728 (char *) "self", NULL
35729 };
35730
35731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
35732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35733 if (SWIG_arg_fail(1)) SWIG_fail;
35734 {
35735 PyThreadState* __tstate = wxPyBeginAllowThreads();
35736 {
35737 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
35738 result = (wxString *) &_result_ref;
35739 }
35740
35741 wxPyEndAllowThreads(__tstate);
35742 if (PyErr_Occurred()) SWIG_fail;
35743 }
35744 {
35745 #if wxUSE_UNICODE
35746 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35747 #else
35748 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35749 #endif
35750 }
35751 return resultobj;
35752 fail:
35753 return NULL;
35754 }
35755
35756
35757 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35758 PyObject *resultobj;
35759 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35760 wxAcceleratorEntry *result;
35761 PyObject * obj0 = 0 ;
35762 char *kwnames[] = {
35763 (char *) "self", NULL
35764 };
35765
35766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
35767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35768 if (SWIG_arg_fail(1)) SWIG_fail;
35769 {
35770 PyThreadState* __tstate = wxPyBeginAllowThreads();
35771 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
35772
35773 wxPyEndAllowThreads(__tstate);
35774 if (PyErr_Occurred()) SWIG_fail;
35775 }
35776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
35777 return resultobj;
35778 fail:
35779 return NULL;
35780 }
35781
35782
35783 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
35784 PyObject *resultobj;
35785 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35786 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
35787 PyObject * obj0 = 0 ;
35788 PyObject * obj1 = 0 ;
35789 char *kwnames[] = {
35790 (char *) "self",(char *) "accel", NULL
35791 };
35792
35793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
35794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35795 if (SWIG_arg_fail(1)) SWIG_fail;
35796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
35797 if (SWIG_arg_fail(2)) SWIG_fail;
35798 {
35799 PyThreadState* __tstate = wxPyBeginAllowThreads();
35800 (arg1)->SetAccel(arg2);
35801
35802 wxPyEndAllowThreads(__tstate);
35803 if (PyErr_Occurred()) SWIG_fail;
35804 }
35805 Py_INCREF(Py_None); resultobj = Py_None;
35806 return resultobj;
35807 fail:
35808 return NULL;
35809 }
35810
35811
35812 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
35813 PyObject *resultobj;
35814 int result;
35815 char *kwnames[] = {
35816 NULL
35817 };
35818
35819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
35820 {
35821 PyThreadState* __tstate = wxPyBeginAllowThreads();
35822 result = (int)MenuItem_GetDefaultMarginWidth();
35823
35824 wxPyEndAllowThreads(__tstate);
35825 if (PyErr_Occurred()) SWIG_fail;
35826 }
35827 {
35828 resultobj = SWIG_From_int((int)(result));
35829 }
35830 return resultobj;
35831 fail:
35832 return NULL;
35833 }
35834
35835
35836 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
35837 PyObject *resultobj;
35838 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35839 wxBitmap *arg2 = 0 ;
35840 PyObject * obj0 = 0 ;
35841 PyObject * obj1 = 0 ;
35842 char *kwnames[] = {
35843 (char *) "self",(char *) "bitmap", NULL
35844 };
35845
35846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
35847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35848 if (SWIG_arg_fail(1)) SWIG_fail;
35849 {
35850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
35851 if (SWIG_arg_fail(2)) SWIG_fail;
35852 if (arg2 == NULL) {
35853 SWIG_null_ref("wxBitmap");
35854 }
35855 if (SWIG_arg_fail(2)) SWIG_fail;
35856 }
35857 {
35858 PyThreadState* __tstate = wxPyBeginAllowThreads();
35859 (arg1)->SetBitmap((wxBitmap const &)*arg2);
35860
35861 wxPyEndAllowThreads(__tstate);
35862 if (PyErr_Occurred()) SWIG_fail;
35863 }
35864 Py_INCREF(Py_None); resultobj = Py_None;
35865 return resultobj;
35866 fail:
35867 return NULL;
35868 }
35869
35870
35871 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
35872 PyObject *resultobj;
35873 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35874 wxBitmap *result;
35875 PyObject * obj0 = 0 ;
35876 char *kwnames[] = {
35877 (char *) "self", NULL
35878 };
35879
35880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
35881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35882 if (SWIG_arg_fail(1)) SWIG_fail;
35883 {
35884 PyThreadState* __tstate = wxPyBeginAllowThreads();
35885 {
35886 wxBitmap const &_result_ref = (arg1)->GetBitmap();
35887 result = (wxBitmap *) &_result_ref;
35888 }
35889
35890 wxPyEndAllowThreads(__tstate);
35891 if (PyErr_Occurred()) SWIG_fail;
35892 }
35893 {
35894 wxBitmap* resultptr = new wxBitmap(*result);
35895 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
35896 }
35897 return resultobj;
35898 fail:
35899 return NULL;
35900 }
35901
35902
35903 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
35904 PyObject *obj;
35905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35906 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
35907 Py_INCREF(obj);
35908 return Py_BuildValue((char *)"");
35909 }
35910 static int _wrap_ControlNameStr_set(PyObject *) {
35911 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
35912 return 1;
35913 }
35914
35915
35916 static PyObject *_wrap_ControlNameStr_get(void) {
35917 PyObject *pyobj;
35918
35919 {
35920 #if wxUSE_UNICODE
35921 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
35922 #else
35923 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
35924 #endif
35925 }
35926 return pyobj;
35927 }
35928
35929
35930 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
35931 PyObject *resultobj;
35932 wxWindow *arg1 = (wxWindow *) 0 ;
35933 int arg2 = (int) -1 ;
35934 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35935 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35936 wxSize const &arg4_defvalue = wxDefaultSize ;
35937 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35938 long arg5 = (long) 0 ;
35939 wxValidator const &arg6_defvalue = wxDefaultValidator ;
35940 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
35941 wxString const &arg7_defvalue = wxPyControlNameStr ;
35942 wxString *arg7 = (wxString *) &arg7_defvalue ;
35943 wxControl *result;
35944 wxPoint temp3 ;
35945 wxSize temp4 ;
35946 bool temp7 = false ;
35947 PyObject * obj0 = 0 ;
35948 PyObject * obj1 = 0 ;
35949 PyObject * obj2 = 0 ;
35950 PyObject * obj3 = 0 ;
35951 PyObject * obj4 = 0 ;
35952 PyObject * obj5 = 0 ;
35953 PyObject * obj6 = 0 ;
35954 char *kwnames[] = {
35955 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
35956 };
35957
35958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
35959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35960 if (SWIG_arg_fail(1)) SWIG_fail;
35961 if (obj1) {
35962 {
35963 arg2 = (int)(SWIG_As_int(obj1));
35964 if (SWIG_arg_fail(2)) SWIG_fail;
35965 }
35966 }
35967 if (obj2) {
35968 {
35969 arg3 = &temp3;
35970 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35971 }
35972 }
35973 if (obj3) {
35974 {
35975 arg4 = &temp4;
35976 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35977 }
35978 }
35979 if (obj4) {
35980 {
35981 arg5 = (long)(SWIG_As_long(obj4));
35982 if (SWIG_arg_fail(5)) SWIG_fail;
35983 }
35984 }
35985 if (obj5) {
35986 {
35987 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
35988 if (SWIG_arg_fail(6)) SWIG_fail;
35989 if (arg6 == NULL) {
35990 SWIG_null_ref("wxValidator");
35991 }
35992 if (SWIG_arg_fail(6)) SWIG_fail;
35993 }
35994 }
35995 if (obj6) {
35996 {
35997 arg7 = wxString_in_helper(obj6);
35998 if (arg7 == NULL) SWIG_fail;
35999 temp7 = true;
36000 }
36001 }
36002 {
36003 if (!wxPyCheckForApp()) SWIG_fail;
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36006
36007 wxPyEndAllowThreads(__tstate);
36008 if (PyErr_Occurred()) SWIG_fail;
36009 }
36010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36011 {
36012 if (temp7)
36013 delete arg7;
36014 }
36015 return resultobj;
36016 fail:
36017 {
36018 if (temp7)
36019 delete arg7;
36020 }
36021 return NULL;
36022 }
36023
36024
36025 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36026 PyObject *resultobj;
36027 wxControl *result;
36028 char *kwnames[] = {
36029 NULL
36030 };
36031
36032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36033 {
36034 if (!wxPyCheckForApp()) SWIG_fail;
36035 PyThreadState* __tstate = wxPyBeginAllowThreads();
36036 result = (wxControl *)new wxControl();
36037
36038 wxPyEndAllowThreads(__tstate);
36039 if (PyErr_Occurred()) SWIG_fail;
36040 }
36041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36042 return resultobj;
36043 fail:
36044 return NULL;
36045 }
36046
36047
36048 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36049 PyObject *resultobj;
36050 wxControl *arg1 = (wxControl *) 0 ;
36051 wxWindow *arg2 = (wxWindow *) 0 ;
36052 int arg3 = (int) -1 ;
36053 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36054 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36055 wxSize const &arg5_defvalue = wxDefaultSize ;
36056 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36057 long arg6 = (long) 0 ;
36058 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36059 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36060 wxString const &arg8_defvalue = wxPyControlNameStr ;
36061 wxString *arg8 = (wxString *) &arg8_defvalue ;
36062 bool result;
36063 wxPoint temp4 ;
36064 wxSize temp5 ;
36065 bool temp8 = false ;
36066 PyObject * obj0 = 0 ;
36067 PyObject * obj1 = 0 ;
36068 PyObject * obj2 = 0 ;
36069 PyObject * obj3 = 0 ;
36070 PyObject * obj4 = 0 ;
36071 PyObject * obj5 = 0 ;
36072 PyObject * obj6 = 0 ;
36073 PyObject * obj7 = 0 ;
36074 char *kwnames[] = {
36075 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36076 };
36077
36078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36080 if (SWIG_arg_fail(1)) SWIG_fail;
36081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36082 if (SWIG_arg_fail(2)) SWIG_fail;
36083 if (obj2) {
36084 {
36085 arg3 = (int)(SWIG_As_int(obj2));
36086 if (SWIG_arg_fail(3)) SWIG_fail;
36087 }
36088 }
36089 if (obj3) {
36090 {
36091 arg4 = &temp4;
36092 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36093 }
36094 }
36095 if (obj4) {
36096 {
36097 arg5 = &temp5;
36098 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36099 }
36100 }
36101 if (obj5) {
36102 {
36103 arg6 = (long)(SWIG_As_long(obj5));
36104 if (SWIG_arg_fail(6)) SWIG_fail;
36105 }
36106 }
36107 if (obj6) {
36108 {
36109 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36110 if (SWIG_arg_fail(7)) SWIG_fail;
36111 if (arg7 == NULL) {
36112 SWIG_null_ref("wxValidator");
36113 }
36114 if (SWIG_arg_fail(7)) SWIG_fail;
36115 }
36116 }
36117 if (obj7) {
36118 {
36119 arg8 = wxString_in_helper(obj7);
36120 if (arg8 == NULL) SWIG_fail;
36121 temp8 = true;
36122 }
36123 }
36124 {
36125 PyThreadState* __tstate = wxPyBeginAllowThreads();
36126 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36127
36128 wxPyEndAllowThreads(__tstate);
36129 if (PyErr_Occurred()) SWIG_fail;
36130 }
36131 {
36132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36133 }
36134 {
36135 if (temp8)
36136 delete arg8;
36137 }
36138 return resultobj;
36139 fail:
36140 {
36141 if (temp8)
36142 delete arg8;
36143 }
36144 return NULL;
36145 }
36146
36147
36148 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36149 PyObject *resultobj;
36150 wxControl *arg1 = (wxControl *) 0 ;
36151 wxCommandEvent *arg2 = 0 ;
36152 PyObject * obj0 = 0 ;
36153 PyObject * obj1 = 0 ;
36154 char *kwnames[] = {
36155 (char *) "self",(char *) "event", NULL
36156 };
36157
36158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36160 if (SWIG_arg_fail(1)) SWIG_fail;
36161 {
36162 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
36163 if (SWIG_arg_fail(2)) SWIG_fail;
36164 if (arg2 == NULL) {
36165 SWIG_null_ref("wxCommandEvent");
36166 }
36167 if (SWIG_arg_fail(2)) SWIG_fail;
36168 }
36169 {
36170 PyThreadState* __tstate = wxPyBeginAllowThreads();
36171 (arg1)->Command(*arg2);
36172
36173 wxPyEndAllowThreads(__tstate);
36174 if (PyErr_Occurred()) SWIG_fail;
36175 }
36176 Py_INCREF(Py_None); resultobj = Py_None;
36177 return resultobj;
36178 fail:
36179 return NULL;
36180 }
36181
36182
36183 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36184 PyObject *resultobj;
36185 wxControl *arg1 = (wxControl *) 0 ;
36186 wxString result;
36187 PyObject * obj0 = 0 ;
36188 char *kwnames[] = {
36189 (char *) "self", NULL
36190 };
36191
36192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
36193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36194 if (SWIG_arg_fail(1)) SWIG_fail;
36195 {
36196 PyThreadState* __tstate = wxPyBeginAllowThreads();
36197 result = (arg1)->GetLabel();
36198
36199 wxPyEndAllowThreads(__tstate);
36200 if (PyErr_Occurred()) SWIG_fail;
36201 }
36202 {
36203 #if wxUSE_UNICODE
36204 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36205 #else
36206 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36207 #endif
36208 }
36209 return resultobj;
36210 fail:
36211 return NULL;
36212 }
36213
36214
36215 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36216 PyObject *resultobj;
36217 wxControl *arg1 = (wxControl *) 0 ;
36218 wxString *arg2 = 0 ;
36219 bool temp2 = false ;
36220 PyObject * obj0 = 0 ;
36221 PyObject * obj1 = 0 ;
36222 char *kwnames[] = {
36223 (char *) "self",(char *) "label", NULL
36224 };
36225
36226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
36227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36228 if (SWIG_arg_fail(1)) SWIG_fail;
36229 {
36230 arg2 = wxString_in_helper(obj1);
36231 if (arg2 == NULL) SWIG_fail;
36232 temp2 = true;
36233 }
36234 {
36235 PyThreadState* __tstate = wxPyBeginAllowThreads();
36236 (arg1)->SetLabel((wxString const &)*arg2);
36237
36238 wxPyEndAllowThreads(__tstate);
36239 if (PyErr_Occurred()) SWIG_fail;
36240 }
36241 Py_INCREF(Py_None); resultobj = Py_None;
36242 {
36243 if (temp2)
36244 delete arg2;
36245 }
36246 return resultobj;
36247 fail:
36248 {
36249 if (temp2)
36250 delete arg2;
36251 }
36252 return NULL;
36253 }
36254
36255
36256 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
36257 PyObject *resultobj;
36258 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36259 wxVisualAttributes result;
36260 PyObject * obj0 = 0 ;
36261 char *kwnames[] = {
36262 (char *) "variant", NULL
36263 };
36264
36265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
36266 if (obj0) {
36267 {
36268 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
36269 if (SWIG_arg_fail(1)) SWIG_fail;
36270 }
36271 }
36272 {
36273 if (!wxPyCheckForApp()) SWIG_fail;
36274 PyThreadState* __tstate = wxPyBeginAllowThreads();
36275 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
36276
36277 wxPyEndAllowThreads(__tstate);
36278 if (PyErr_Occurred()) SWIG_fail;
36279 }
36280 {
36281 wxVisualAttributes * resultptr;
36282 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
36283 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
36284 }
36285 return resultobj;
36286 fail:
36287 return NULL;
36288 }
36289
36290
36291 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
36292 PyObject *obj;
36293 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36294 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
36295 Py_INCREF(obj);
36296 return Py_BuildValue((char *)"");
36297 }
36298 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
36299 PyObject *resultobj;
36300 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36301 wxString *arg2 = 0 ;
36302 PyObject *arg3 = (PyObject *) NULL ;
36303 int result;
36304 bool temp2 = false ;
36305 PyObject * obj0 = 0 ;
36306 PyObject * obj1 = 0 ;
36307 PyObject * obj2 = 0 ;
36308 char *kwnames[] = {
36309 (char *) "self",(char *) "item",(char *) "clientData", NULL
36310 };
36311
36312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
36313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36314 if (SWIG_arg_fail(1)) SWIG_fail;
36315 {
36316 arg2 = wxString_in_helper(obj1);
36317 if (arg2 == NULL) SWIG_fail;
36318 temp2 = true;
36319 }
36320 if (obj2) {
36321 arg3 = obj2;
36322 }
36323 {
36324 PyThreadState* __tstate = wxPyBeginAllowThreads();
36325 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
36326
36327 wxPyEndAllowThreads(__tstate);
36328 if (PyErr_Occurred()) SWIG_fail;
36329 }
36330 {
36331 resultobj = SWIG_From_int((int)(result));
36332 }
36333 {
36334 if (temp2)
36335 delete arg2;
36336 }
36337 return resultobj;
36338 fail:
36339 {
36340 if (temp2)
36341 delete arg2;
36342 }
36343 return NULL;
36344 }
36345
36346
36347 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
36348 PyObject *resultobj;
36349 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36350 wxArrayString *arg2 = 0 ;
36351 bool temp2 = false ;
36352 PyObject * obj0 = 0 ;
36353 PyObject * obj1 = 0 ;
36354 char *kwnames[] = {
36355 (char *) "self",(char *) "strings", NULL
36356 };
36357
36358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
36359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36360 if (SWIG_arg_fail(1)) SWIG_fail;
36361 {
36362 if (! PySequence_Check(obj1)) {
36363 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
36364 SWIG_fail;
36365 }
36366 arg2 = new wxArrayString;
36367 temp2 = true;
36368 int i, len=PySequence_Length(obj1);
36369 for (i=0; i<len; i++) {
36370 PyObject* item = PySequence_GetItem(obj1, i);
36371 #if wxUSE_UNICODE
36372 PyObject* str = PyObject_Unicode(item);
36373 #else
36374 PyObject* str = PyObject_Str(item);
36375 #endif
36376 if (PyErr_Occurred()) SWIG_fail;
36377 arg2->Add(Py2wxString(str));
36378 Py_DECREF(item);
36379 Py_DECREF(str);
36380 }
36381 }
36382 {
36383 PyThreadState* __tstate = wxPyBeginAllowThreads();
36384 (arg1)->Append((wxArrayString const &)*arg2);
36385
36386 wxPyEndAllowThreads(__tstate);
36387 if (PyErr_Occurred()) SWIG_fail;
36388 }
36389 Py_INCREF(Py_None); resultobj = Py_None;
36390 {
36391 if (temp2) delete arg2;
36392 }
36393 return resultobj;
36394 fail:
36395 {
36396 if (temp2) delete arg2;
36397 }
36398 return NULL;
36399 }
36400
36401
36402 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
36403 PyObject *resultobj;
36404 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36405 wxString *arg2 = 0 ;
36406 int arg3 ;
36407 PyObject *arg4 = (PyObject *) NULL ;
36408 int result;
36409 bool temp2 = false ;
36410 PyObject * obj0 = 0 ;
36411 PyObject * obj1 = 0 ;
36412 PyObject * obj2 = 0 ;
36413 PyObject * obj3 = 0 ;
36414 char *kwnames[] = {
36415 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
36416 };
36417
36418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
36419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36420 if (SWIG_arg_fail(1)) SWIG_fail;
36421 {
36422 arg2 = wxString_in_helper(obj1);
36423 if (arg2 == NULL) SWIG_fail;
36424 temp2 = true;
36425 }
36426 {
36427 arg3 = (int)(SWIG_As_int(obj2));
36428 if (SWIG_arg_fail(3)) SWIG_fail;
36429 }
36430 if (obj3) {
36431 arg4 = obj3;
36432 }
36433 {
36434 PyThreadState* __tstate = wxPyBeginAllowThreads();
36435 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
36436
36437 wxPyEndAllowThreads(__tstate);
36438 if (PyErr_Occurred()) SWIG_fail;
36439 }
36440 {
36441 resultobj = SWIG_From_int((int)(result));
36442 }
36443 {
36444 if (temp2)
36445 delete arg2;
36446 }
36447 return resultobj;
36448 fail:
36449 {
36450 if (temp2)
36451 delete arg2;
36452 }
36453 return NULL;
36454 }
36455
36456
36457 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
36458 PyObject *resultobj;
36459 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36460 PyObject * obj0 = 0 ;
36461 char *kwnames[] = {
36462 (char *) "self", NULL
36463 };
36464
36465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
36466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36467 if (SWIG_arg_fail(1)) SWIG_fail;
36468 {
36469 PyThreadState* __tstate = wxPyBeginAllowThreads();
36470 (arg1)->Clear();
36471
36472 wxPyEndAllowThreads(__tstate);
36473 if (PyErr_Occurred()) SWIG_fail;
36474 }
36475 Py_INCREF(Py_None); resultobj = Py_None;
36476 return resultobj;
36477 fail:
36478 return NULL;
36479 }
36480
36481
36482 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
36483 PyObject *resultobj;
36484 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36485 int arg2 ;
36486 PyObject * obj0 = 0 ;
36487 PyObject * obj1 = 0 ;
36488 char *kwnames[] = {
36489 (char *) "self",(char *) "n", NULL
36490 };
36491
36492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
36493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36494 if (SWIG_arg_fail(1)) SWIG_fail;
36495 {
36496 arg2 = (int)(SWIG_As_int(obj1));
36497 if (SWIG_arg_fail(2)) SWIG_fail;
36498 }
36499 {
36500 PyThreadState* __tstate = wxPyBeginAllowThreads();
36501 (arg1)->Delete(arg2);
36502
36503 wxPyEndAllowThreads(__tstate);
36504 if (PyErr_Occurred()) SWIG_fail;
36505 }
36506 Py_INCREF(Py_None); resultobj = Py_None;
36507 return resultobj;
36508 fail:
36509 return NULL;
36510 }
36511
36512
36513 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
36514 PyObject *resultobj;
36515 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36516 int result;
36517 PyObject * obj0 = 0 ;
36518 char *kwnames[] = {
36519 (char *) "self", NULL
36520 };
36521
36522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
36523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36524 if (SWIG_arg_fail(1)) SWIG_fail;
36525 {
36526 PyThreadState* __tstate = wxPyBeginAllowThreads();
36527 result = (int)((wxItemContainer const *)arg1)->GetCount();
36528
36529 wxPyEndAllowThreads(__tstate);
36530 if (PyErr_Occurred()) SWIG_fail;
36531 }
36532 {
36533 resultobj = SWIG_From_int((int)(result));
36534 }
36535 return resultobj;
36536 fail:
36537 return NULL;
36538 }
36539
36540
36541 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
36542 PyObject *resultobj;
36543 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36544 bool result;
36545 PyObject * obj0 = 0 ;
36546 char *kwnames[] = {
36547 (char *) "self", NULL
36548 };
36549
36550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
36551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36552 if (SWIG_arg_fail(1)) SWIG_fail;
36553 {
36554 PyThreadState* __tstate = wxPyBeginAllowThreads();
36555 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
36556
36557 wxPyEndAllowThreads(__tstate);
36558 if (PyErr_Occurred()) SWIG_fail;
36559 }
36560 {
36561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36562 }
36563 return resultobj;
36564 fail:
36565 return NULL;
36566 }
36567
36568
36569 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
36570 PyObject *resultobj;
36571 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36572 int arg2 ;
36573 wxString result;
36574 PyObject * obj0 = 0 ;
36575 PyObject * obj1 = 0 ;
36576 char *kwnames[] = {
36577 (char *) "self",(char *) "n", NULL
36578 };
36579
36580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
36581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36582 if (SWIG_arg_fail(1)) SWIG_fail;
36583 {
36584 arg2 = (int)(SWIG_As_int(obj1));
36585 if (SWIG_arg_fail(2)) SWIG_fail;
36586 }
36587 {
36588 PyThreadState* __tstate = wxPyBeginAllowThreads();
36589 result = ((wxItemContainer const *)arg1)->GetString(arg2);
36590
36591 wxPyEndAllowThreads(__tstate);
36592 if (PyErr_Occurred()) SWIG_fail;
36593 }
36594 {
36595 #if wxUSE_UNICODE
36596 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36597 #else
36598 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36599 #endif
36600 }
36601 return resultobj;
36602 fail:
36603 return NULL;
36604 }
36605
36606
36607 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
36608 PyObject *resultobj;
36609 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36610 wxArrayString result;
36611 PyObject * obj0 = 0 ;
36612 char *kwnames[] = {
36613 (char *) "self", NULL
36614 };
36615
36616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
36617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36618 if (SWIG_arg_fail(1)) SWIG_fail;
36619 {
36620 PyThreadState* __tstate = wxPyBeginAllowThreads();
36621 result = ((wxItemContainer const *)arg1)->GetStrings();
36622
36623 wxPyEndAllowThreads(__tstate);
36624 if (PyErr_Occurred()) SWIG_fail;
36625 }
36626 {
36627 resultobj = wxArrayString2PyList_helper(result);
36628 }
36629 return resultobj;
36630 fail:
36631 return NULL;
36632 }
36633
36634
36635 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
36636 PyObject *resultobj;
36637 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36638 int arg2 ;
36639 wxString *arg3 = 0 ;
36640 bool temp3 = false ;
36641 PyObject * obj0 = 0 ;
36642 PyObject * obj1 = 0 ;
36643 PyObject * obj2 = 0 ;
36644 char *kwnames[] = {
36645 (char *) "self",(char *) "n",(char *) "s", NULL
36646 };
36647
36648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36650 if (SWIG_arg_fail(1)) SWIG_fail;
36651 {
36652 arg2 = (int)(SWIG_As_int(obj1));
36653 if (SWIG_arg_fail(2)) SWIG_fail;
36654 }
36655 {
36656 arg3 = wxString_in_helper(obj2);
36657 if (arg3 == NULL) SWIG_fail;
36658 temp3 = true;
36659 }
36660 {
36661 PyThreadState* __tstate = wxPyBeginAllowThreads();
36662 (arg1)->SetString(arg2,(wxString const &)*arg3);
36663
36664 wxPyEndAllowThreads(__tstate);
36665 if (PyErr_Occurred()) SWIG_fail;
36666 }
36667 Py_INCREF(Py_None); resultobj = Py_None;
36668 {
36669 if (temp3)
36670 delete arg3;
36671 }
36672 return resultobj;
36673 fail:
36674 {
36675 if (temp3)
36676 delete arg3;
36677 }
36678 return NULL;
36679 }
36680
36681
36682 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
36683 PyObject *resultobj;
36684 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36685 wxString *arg2 = 0 ;
36686 int result;
36687 bool temp2 = false ;
36688 PyObject * obj0 = 0 ;
36689 PyObject * obj1 = 0 ;
36690 char *kwnames[] = {
36691 (char *) "self",(char *) "s", NULL
36692 };
36693
36694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
36695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36696 if (SWIG_arg_fail(1)) SWIG_fail;
36697 {
36698 arg2 = wxString_in_helper(obj1);
36699 if (arg2 == NULL) SWIG_fail;
36700 temp2 = true;
36701 }
36702 {
36703 PyThreadState* __tstate = wxPyBeginAllowThreads();
36704 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
36705
36706 wxPyEndAllowThreads(__tstate);
36707 if (PyErr_Occurred()) SWIG_fail;
36708 }
36709 {
36710 resultobj = SWIG_From_int((int)(result));
36711 }
36712 {
36713 if (temp2)
36714 delete arg2;
36715 }
36716 return resultobj;
36717 fail:
36718 {
36719 if (temp2)
36720 delete arg2;
36721 }
36722 return NULL;
36723 }
36724
36725
36726 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
36727 PyObject *resultobj;
36728 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36729 int arg2 ;
36730 PyObject * obj0 = 0 ;
36731 PyObject * obj1 = 0 ;
36732 char *kwnames[] = {
36733 (char *) "self",(char *) "n", NULL
36734 };
36735
36736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
36737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36738 if (SWIG_arg_fail(1)) SWIG_fail;
36739 {
36740 arg2 = (int)(SWIG_As_int(obj1));
36741 if (SWIG_arg_fail(2)) SWIG_fail;
36742 }
36743 {
36744 PyThreadState* __tstate = wxPyBeginAllowThreads();
36745 (arg1)->Select(arg2);
36746
36747 wxPyEndAllowThreads(__tstate);
36748 if (PyErr_Occurred()) SWIG_fail;
36749 }
36750 Py_INCREF(Py_None); resultobj = Py_None;
36751 return resultobj;
36752 fail:
36753 return NULL;
36754 }
36755
36756
36757 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36758 PyObject *resultobj;
36759 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36760 int result;
36761 PyObject * obj0 = 0 ;
36762 char *kwnames[] = {
36763 (char *) "self", NULL
36764 };
36765
36766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
36767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36768 if (SWIG_arg_fail(1)) SWIG_fail;
36769 {
36770 PyThreadState* __tstate = wxPyBeginAllowThreads();
36771 result = (int)((wxItemContainer const *)arg1)->GetSelection();
36772
36773 wxPyEndAllowThreads(__tstate);
36774 if (PyErr_Occurred()) SWIG_fail;
36775 }
36776 {
36777 resultobj = SWIG_From_int((int)(result));
36778 }
36779 return resultobj;
36780 fail:
36781 return NULL;
36782 }
36783
36784
36785 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
36786 PyObject *resultobj;
36787 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36788 wxString result;
36789 PyObject * obj0 = 0 ;
36790 char *kwnames[] = {
36791 (char *) "self", NULL
36792 };
36793
36794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
36795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36796 if (SWIG_arg_fail(1)) SWIG_fail;
36797 {
36798 PyThreadState* __tstate = wxPyBeginAllowThreads();
36799 result = ((wxItemContainer const *)arg1)->GetStringSelection();
36800
36801 wxPyEndAllowThreads(__tstate);
36802 if (PyErr_Occurred()) SWIG_fail;
36803 }
36804 {
36805 #if wxUSE_UNICODE
36806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36807 #else
36808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36809 #endif
36810 }
36811 return resultobj;
36812 fail:
36813 return NULL;
36814 }
36815
36816
36817 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36818 PyObject *resultobj;
36819 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36820 int arg2 ;
36821 PyObject *result;
36822 PyObject * obj0 = 0 ;
36823 PyObject * obj1 = 0 ;
36824 char *kwnames[] = {
36825 (char *) "self",(char *) "n", NULL
36826 };
36827
36828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
36829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36830 if (SWIG_arg_fail(1)) SWIG_fail;
36831 {
36832 arg2 = (int)(SWIG_As_int(obj1));
36833 if (SWIG_arg_fail(2)) SWIG_fail;
36834 }
36835 {
36836 PyThreadState* __tstate = wxPyBeginAllowThreads();
36837 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
36838
36839 wxPyEndAllowThreads(__tstate);
36840 if (PyErr_Occurred()) SWIG_fail;
36841 }
36842 resultobj = result;
36843 return resultobj;
36844 fail:
36845 return NULL;
36846 }
36847
36848
36849 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36850 PyObject *resultobj;
36851 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36852 int arg2 ;
36853 PyObject *arg3 = (PyObject *) 0 ;
36854 PyObject * obj0 = 0 ;
36855 PyObject * obj1 = 0 ;
36856 PyObject * obj2 = 0 ;
36857 char *kwnames[] = {
36858 (char *) "self",(char *) "n",(char *) "clientData", NULL
36859 };
36860
36861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
36862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36863 if (SWIG_arg_fail(1)) SWIG_fail;
36864 {
36865 arg2 = (int)(SWIG_As_int(obj1));
36866 if (SWIG_arg_fail(2)) SWIG_fail;
36867 }
36868 arg3 = obj2;
36869 {
36870 PyThreadState* __tstate = wxPyBeginAllowThreads();
36871 wxItemContainer_SetClientData(arg1,arg2,arg3);
36872
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 Py_INCREF(Py_None); resultobj = Py_None;
36877 return resultobj;
36878 fail:
36879 return NULL;
36880 }
36881
36882
36883 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
36884 PyObject *obj;
36885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36886 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
36887 Py_INCREF(obj);
36888 return Py_BuildValue((char *)"");
36889 }
36890 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
36891 PyObject *obj;
36892 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36893 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
36894 Py_INCREF(obj);
36895 return Py_BuildValue((char *)"");
36896 }
36897 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
36898 PyObject *resultobj;
36899 wxSizerItem *result;
36900 char *kwnames[] = {
36901 NULL
36902 };
36903
36904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
36905 {
36906 PyThreadState* __tstate = wxPyBeginAllowThreads();
36907 result = (wxSizerItem *)new wxSizerItem();
36908
36909 wxPyEndAllowThreads(__tstate);
36910 if (PyErr_Occurred()) SWIG_fail;
36911 }
36912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
36913 return resultobj;
36914 fail:
36915 return NULL;
36916 }
36917
36918
36919 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
36920 PyObject *resultobj;
36921 wxWindow *arg1 = (wxWindow *) 0 ;
36922 int arg2 ;
36923 int arg3 ;
36924 int arg4 ;
36925 PyObject *arg5 = (PyObject *) NULL ;
36926 wxSizerItem *result;
36927 PyObject * obj0 = 0 ;
36928 PyObject * obj1 = 0 ;
36929 PyObject * obj2 = 0 ;
36930 PyObject * obj3 = 0 ;
36931 PyObject * obj4 = 0 ;
36932 char *kwnames[] = {
36933 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
36934 };
36935
36936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
36937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36938 if (SWIG_arg_fail(1)) SWIG_fail;
36939 {
36940 arg2 = (int)(SWIG_As_int(obj1));
36941 if (SWIG_arg_fail(2)) SWIG_fail;
36942 }
36943 {
36944 arg3 = (int)(SWIG_As_int(obj2));
36945 if (SWIG_arg_fail(3)) SWIG_fail;
36946 }
36947 {
36948 arg4 = (int)(SWIG_As_int(obj3));
36949 if (SWIG_arg_fail(4)) SWIG_fail;
36950 }
36951 if (obj4) {
36952 arg5 = obj4;
36953 }
36954 {
36955 PyThreadState* __tstate = wxPyBeginAllowThreads();
36956 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
36957
36958 wxPyEndAllowThreads(__tstate);
36959 if (PyErr_Occurred()) SWIG_fail;
36960 }
36961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
36962 return resultobj;
36963 fail:
36964 return NULL;
36965 }
36966
36967
36968 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
36969 PyObject *resultobj;
36970 int arg1 ;
36971 int arg2 ;
36972 int arg3 ;
36973 int arg4 ;
36974 int arg5 ;
36975 PyObject *arg6 = (PyObject *) NULL ;
36976 wxSizerItem *result;
36977 PyObject * obj0 = 0 ;
36978 PyObject * obj1 = 0 ;
36979 PyObject * obj2 = 0 ;
36980 PyObject * obj3 = 0 ;
36981 PyObject * obj4 = 0 ;
36982 PyObject * obj5 = 0 ;
36983 char *kwnames[] = {
36984 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
36985 };
36986
36987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36988 {
36989 arg1 = (int)(SWIG_As_int(obj0));
36990 if (SWIG_arg_fail(1)) SWIG_fail;
36991 }
36992 {
36993 arg2 = (int)(SWIG_As_int(obj1));
36994 if (SWIG_arg_fail(2)) SWIG_fail;
36995 }
36996 {
36997 arg3 = (int)(SWIG_As_int(obj2));
36998 if (SWIG_arg_fail(3)) SWIG_fail;
36999 }
37000 {
37001 arg4 = (int)(SWIG_As_int(obj3));
37002 if (SWIG_arg_fail(4)) SWIG_fail;
37003 }
37004 {
37005 arg5 = (int)(SWIG_As_int(obj4));
37006 if (SWIG_arg_fail(5)) SWIG_fail;
37007 }
37008 if (obj5) {
37009 arg6 = obj5;
37010 }
37011 {
37012 PyThreadState* __tstate = wxPyBeginAllowThreads();
37013 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37014
37015 wxPyEndAllowThreads(__tstate);
37016 if (PyErr_Occurred()) SWIG_fail;
37017 }
37018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37019 return resultobj;
37020 fail:
37021 return NULL;
37022 }
37023
37024
37025 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37026 PyObject *resultobj;
37027 wxSizer *arg1 = (wxSizer *) 0 ;
37028 int arg2 ;
37029 int arg3 ;
37030 int arg4 ;
37031 PyObject *arg5 = (PyObject *) NULL ;
37032 wxSizerItem *result;
37033 PyObject * obj0 = 0 ;
37034 PyObject * obj1 = 0 ;
37035 PyObject * obj2 = 0 ;
37036 PyObject * obj3 = 0 ;
37037 PyObject * obj4 = 0 ;
37038 char *kwnames[] = {
37039 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37040 };
37041
37042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37044 if (SWIG_arg_fail(1)) SWIG_fail;
37045 {
37046 arg2 = (int)(SWIG_As_int(obj1));
37047 if (SWIG_arg_fail(2)) SWIG_fail;
37048 }
37049 {
37050 arg3 = (int)(SWIG_As_int(obj2));
37051 if (SWIG_arg_fail(3)) SWIG_fail;
37052 }
37053 {
37054 arg4 = (int)(SWIG_As_int(obj3));
37055 if (SWIG_arg_fail(4)) SWIG_fail;
37056 }
37057 if (obj4) {
37058 arg5 = obj4;
37059 }
37060 {
37061 PyThreadState* __tstate = wxPyBeginAllowThreads();
37062 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37063
37064 wxPyEndAllowThreads(__tstate);
37065 if (PyErr_Occurred()) SWIG_fail;
37066 }
37067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37068 return resultobj;
37069 fail:
37070 return NULL;
37071 }
37072
37073
37074 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37075 PyObject *resultobj;
37076 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37077 PyObject * obj0 = 0 ;
37078 char *kwnames[] = {
37079 (char *) "self", NULL
37080 };
37081
37082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37084 if (SWIG_arg_fail(1)) SWIG_fail;
37085 {
37086 PyThreadState* __tstate = wxPyBeginAllowThreads();
37087 (arg1)->DeleteWindows();
37088
37089 wxPyEndAllowThreads(__tstate);
37090 if (PyErr_Occurred()) SWIG_fail;
37091 }
37092 Py_INCREF(Py_None); resultobj = Py_None;
37093 return resultobj;
37094 fail:
37095 return NULL;
37096 }
37097
37098
37099 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37100 PyObject *resultobj;
37101 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37102 PyObject * obj0 = 0 ;
37103 char *kwnames[] = {
37104 (char *) "self", NULL
37105 };
37106
37107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
37108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37109 if (SWIG_arg_fail(1)) SWIG_fail;
37110 {
37111 PyThreadState* __tstate = wxPyBeginAllowThreads();
37112 (arg1)->DetachSizer();
37113
37114 wxPyEndAllowThreads(__tstate);
37115 if (PyErr_Occurred()) SWIG_fail;
37116 }
37117 Py_INCREF(Py_None); resultobj = Py_None;
37118 return resultobj;
37119 fail:
37120 return NULL;
37121 }
37122
37123
37124 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
37125 PyObject *resultobj;
37126 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37127 wxSize result;
37128 PyObject * obj0 = 0 ;
37129 char *kwnames[] = {
37130 (char *) "self", NULL
37131 };
37132
37133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
37134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37135 if (SWIG_arg_fail(1)) SWIG_fail;
37136 {
37137 PyThreadState* __tstate = wxPyBeginAllowThreads();
37138 result = (arg1)->GetSize();
37139
37140 wxPyEndAllowThreads(__tstate);
37141 if (PyErr_Occurred()) SWIG_fail;
37142 }
37143 {
37144 wxSize * resultptr;
37145 resultptr = new wxSize((wxSize &)(result));
37146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37147 }
37148 return resultobj;
37149 fail:
37150 return NULL;
37151 }
37152
37153
37154 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
37155 PyObject *resultobj;
37156 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37157 wxSize result;
37158 PyObject * obj0 = 0 ;
37159 char *kwnames[] = {
37160 (char *) "self", NULL
37161 };
37162
37163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
37164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37165 if (SWIG_arg_fail(1)) SWIG_fail;
37166 {
37167 PyThreadState* __tstate = wxPyBeginAllowThreads();
37168 result = (arg1)->CalcMin();
37169
37170 wxPyEndAllowThreads(__tstate);
37171 if (PyErr_Occurred()) SWIG_fail;
37172 }
37173 {
37174 wxSize * resultptr;
37175 resultptr = new wxSize((wxSize &)(result));
37176 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37177 }
37178 return resultobj;
37179 fail:
37180 return NULL;
37181 }
37182
37183
37184 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
37185 PyObject *resultobj;
37186 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37187 wxPoint arg2 ;
37188 wxSize arg3 ;
37189 PyObject * obj0 = 0 ;
37190 PyObject * obj1 = 0 ;
37191 PyObject * obj2 = 0 ;
37192 char *kwnames[] = {
37193 (char *) "self",(char *) "pos",(char *) "size", NULL
37194 };
37195
37196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
37197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37198 if (SWIG_arg_fail(1)) SWIG_fail;
37199 {
37200 wxPoint * argp;
37201 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
37202 if (SWIG_arg_fail(2)) SWIG_fail;
37203 if (argp == NULL) {
37204 SWIG_null_ref("wxPoint");
37205 }
37206 if (SWIG_arg_fail(2)) SWIG_fail;
37207 arg2 = *argp;
37208 }
37209 {
37210 wxSize * argp;
37211 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37212 if (SWIG_arg_fail(3)) SWIG_fail;
37213 if (argp == NULL) {
37214 SWIG_null_ref("wxSize");
37215 }
37216 if (SWIG_arg_fail(3)) SWIG_fail;
37217 arg3 = *argp;
37218 }
37219 {
37220 PyThreadState* __tstate = wxPyBeginAllowThreads();
37221 (arg1)->SetDimension(arg2,arg3);
37222
37223 wxPyEndAllowThreads(__tstate);
37224 if (PyErr_Occurred()) SWIG_fail;
37225 }
37226 Py_INCREF(Py_None); resultobj = Py_None;
37227 return resultobj;
37228 fail:
37229 return NULL;
37230 }
37231
37232
37233 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
37234 PyObject *resultobj;
37235 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37236 wxSize result;
37237 PyObject * obj0 = 0 ;
37238 char *kwnames[] = {
37239 (char *) "self", NULL
37240 };
37241
37242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
37243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37244 if (SWIG_arg_fail(1)) SWIG_fail;
37245 {
37246 PyThreadState* __tstate = wxPyBeginAllowThreads();
37247 result = (arg1)->GetMinSize();
37248
37249 wxPyEndAllowThreads(__tstate);
37250 if (PyErr_Occurred()) SWIG_fail;
37251 }
37252 {
37253 wxSize * resultptr;
37254 resultptr = new wxSize((wxSize &)(result));
37255 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37256 }
37257 return resultobj;
37258 fail:
37259 return NULL;
37260 }
37261
37262
37263 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37264 PyObject *resultobj;
37265 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37266 wxSize result;
37267 PyObject * obj0 = 0 ;
37268 char *kwnames[] = {
37269 (char *) "self", NULL
37270 };
37271
37272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
37273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37274 if (SWIG_arg_fail(1)) SWIG_fail;
37275 {
37276 PyThreadState* __tstate = wxPyBeginAllowThreads();
37277 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
37278
37279 wxPyEndAllowThreads(__tstate);
37280 if (PyErr_Occurred()) SWIG_fail;
37281 }
37282 {
37283 wxSize * resultptr;
37284 resultptr = new wxSize((wxSize &)(result));
37285 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37286 }
37287 return resultobj;
37288 fail:
37289 return NULL;
37290 }
37291
37292
37293 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
37294 PyObject *resultobj;
37295 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37296 int arg2 ;
37297 int arg3 ;
37298 PyObject * obj0 = 0 ;
37299 PyObject * obj1 = 0 ;
37300 PyObject * obj2 = 0 ;
37301 char *kwnames[] = {
37302 (char *) "self",(char *) "x",(char *) "y", NULL
37303 };
37304
37305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
37306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37307 if (SWIG_arg_fail(1)) SWIG_fail;
37308 {
37309 arg2 = (int)(SWIG_As_int(obj1));
37310 if (SWIG_arg_fail(2)) SWIG_fail;
37311 }
37312 {
37313 arg3 = (int)(SWIG_As_int(obj2));
37314 if (SWIG_arg_fail(3)) SWIG_fail;
37315 }
37316 {
37317 PyThreadState* __tstate = wxPyBeginAllowThreads();
37318 (arg1)->SetInitSize(arg2,arg3);
37319
37320 wxPyEndAllowThreads(__tstate);
37321 if (PyErr_Occurred()) SWIG_fail;
37322 }
37323 Py_INCREF(Py_None); resultobj = Py_None;
37324 return resultobj;
37325 fail:
37326 return NULL;
37327 }
37328
37329
37330 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
37331 PyObject *resultobj;
37332 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37333 int arg2 ;
37334 int arg3 ;
37335 PyObject * obj0 = 0 ;
37336 PyObject * obj1 = 0 ;
37337 PyObject * obj2 = 0 ;
37338 char *kwnames[] = {
37339 (char *) "self",(char *) "width",(char *) "height", NULL
37340 };
37341
37342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
37343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37344 if (SWIG_arg_fail(1)) SWIG_fail;
37345 {
37346 arg2 = (int)(SWIG_As_int(obj1));
37347 if (SWIG_arg_fail(2)) SWIG_fail;
37348 }
37349 {
37350 arg3 = (int)(SWIG_As_int(obj2));
37351 if (SWIG_arg_fail(3)) SWIG_fail;
37352 }
37353 {
37354 PyThreadState* __tstate = wxPyBeginAllowThreads();
37355 (arg1)->SetRatio(arg2,arg3);
37356
37357 wxPyEndAllowThreads(__tstate);
37358 if (PyErr_Occurred()) SWIG_fail;
37359 }
37360 Py_INCREF(Py_None); resultobj = Py_None;
37361 return resultobj;
37362 fail:
37363 return NULL;
37364 }
37365
37366
37367 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
37368 PyObject *resultobj;
37369 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37370 wxSize arg2 ;
37371 PyObject * obj0 = 0 ;
37372 PyObject * obj1 = 0 ;
37373 char *kwnames[] = {
37374 (char *) "self",(char *) "size", NULL
37375 };
37376
37377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
37378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37379 if (SWIG_arg_fail(1)) SWIG_fail;
37380 {
37381 wxSize * argp;
37382 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37383 if (SWIG_arg_fail(2)) SWIG_fail;
37384 if (argp == NULL) {
37385 SWIG_null_ref("wxSize");
37386 }
37387 if (SWIG_arg_fail(2)) SWIG_fail;
37388 arg2 = *argp;
37389 }
37390 {
37391 PyThreadState* __tstate = wxPyBeginAllowThreads();
37392 (arg1)->SetRatio(arg2);
37393
37394 wxPyEndAllowThreads(__tstate);
37395 if (PyErr_Occurred()) SWIG_fail;
37396 }
37397 Py_INCREF(Py_None); resultobj = Py_None;
37398 return resultobj;
37399 fail:
37400 return NULL;
37401 }
37402
37403
37404 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37405 PyObject *resultobj;
37406 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37407 float arg2 ;
37408 PyObject * obj0 = 0 ;
37409 PyObject * obj1 = 0 ;
37410 char *kwnames[] = {
37411 (char *) "self",(char *) "ratio", NULL
37412 };
37413
37414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
37415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37416 if (SWIG_arg_fail(1)) SWIG_fail;
37417 {
37418 arg2 = (float)(SWIG_As_float(obj1));
37419 if (SWIG_arg_fail(2)) SWIG_fail;
37420 }
37421 {
37422 PyThreadState* __tstate = wxPyBeginAllowThreads();
37423 (arg1)->SetRatio(arg2);
37424
37425 wxPyEndAllowThreads(__tstate);
37426 if (PyErr_Occurred()) SWIG_fail;
37427 }
37428 Py_INCREF(Py_None); resultobj = Py_None;
37429 return resultobj;
37430 fail:
37431 return NULL;
37432 }
37433
37434
37435 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37436 PyObject *resultobj;
37437 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37438 float result;
37439 PyObject * obj0 = 0 ;
37440 char *kwnames[] = {
37441 (char *) "self", NULL
37442 };
37443
37444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
37445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37446 if (SWIG_arg_fail(1)) SWIG_fail;
37447 {
37448 PyThreadState* __tstate = wxPyBeginAllowThreads();
37449 result = (float)(arg1)->GetRatio();
37450
37451 wxPyEndAllowThreads(__tstate);
37452 if (PyErr_Occurred()) SWIG_fail;
37453 }
37454 {
37455 resultobj = SWIG_From_float((float)(result));
37456 }
37457 return resultobj;
37458 fail:
37459 return NULL;
37460 }
37461
37462
37463 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
37464 PyObject *resultobj;
37465 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37466 wxRect result;
37467 PyObject * obj0 = 0 ;
37468 char *kwnames[] = {
37469 (char *) "self", NULL
37470 };
37471
37472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
37473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37474 if (SWIG_arg_fail(1)) SWIG_fail;
37475 {
37476 PyThreadState* __tstate = wxPyBeginAllowThreads();
37477 result = (arg1)->GetRect();
37478
37479 wxPyEndAllowThreads(__tstate);
37480 if (PyErr_Occurred()) SWIG_fail;
37481 }
37482 {
37483 wxRect * resultptr;
37484 resultptr = new wxRect((wxRect &)(result));
37485 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
37486 }
37487 return resultobj;
37488 fail:
37489 return NULL;
37490 }
37491
37492
37493 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37494 PyObject *resultobj;
37495 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37496 bool result;
37497 PyObject * obj0 = 0 ;
37498 char *kwnames[] = {
37499 (char *) "self", NULL
37500 };
37501
37502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
37503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37504 if (SWIG_arg_fail(1)) SWIG_fail;
37505 {
37506 PyThreadState* __tstate = wxPyBeginAllowThreads();
37507 result = (bool)(arg1)->IsWindow();
37508
37509 wxPyEndAllowThreads(__tstate);
37510 if (PyErr_Occurred()) SWIG_fail;
37511 }
37512 {
37513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37514 }
37515 return resultobj;
37516 fail:
37517 return NULL;
37518 }
37519
37520
37521 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37522 PyObject *resultobj;
37523 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37524 bool result;
37525 PyObject * obj0 = 0 ;
37526 char *kwnames[] = {
37527 (char *) "self", NULL
37528 };
37529
37530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
37531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37532 if (SWIG_arg_fail(1)) SWIG_fail;
37533 {
37534 PyThreadState* __tstate = wxPyBeginAllowThreads();
37535 result = (bool)(arg1)->IsSizer();
37536
37537 wxPyEndAllowThreads(__tstate);
37538 if (PyErr_Occurred()) SWIG_fail;
37539 }
37540 {
37541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37542 }
37543 return resultobj;
37544 fail:
37545 return NULL;
37546 }
37547
37548
37549 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37550 PyObject *resultobj;
37551 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37552 bool result;
37553 PyObject * obj0 = 0 ;
37554 char *kwnames[] = {
37555 (char *) "self", NULL
37556 };
37557
37558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
37559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37560 if (SWIG_arg_fail(1)) SWIG_fail;
37561 {
37562 PyThreadState* __tstate = wxPyBeginAllowThreads();
37563 result = (bool)(arg1)->IsSpacer();
37564
37565 wxPyEndAllowThreads(__tstate);
37566 if (PyErr_Occurred()) SWIG_fail;
37567 }
37568 {
37569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37570 }
37571 return resultobj;
37572 fail:
37573 return NULL;
37574 }
37575
37576
37577 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37578 PyObject *resultobj;
37579 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37580 int arg2 ;
37581 PyObject * obj0 = 0 ;
37582 PyObject * obj1 = 0 ;
37583 char *kwnames[] = {
37584 (char *) "self",(char *) "proportion", NULL
37585 };
37586
37587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
37588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37589 if (SWIG_arg_fail(1)) SWIG_fail;
37590 {
37591 arg2 = (int)(SWIG_As_int(obj1));
37592 if (SWIG_arg_fail(2)) SWIG_fail;
37593 }
37594 {
37595 PyThreadState* __tstate = wxPyBeginAllowThreads();
37596 (arg1)->SetProportion(arg2);
37597
37598 wxPyEndAllowThreads(__tstate);
37599 if (PyErr_Occurred()) SWIG_fail;
37600 }
37601 Py_INCREF(Py_None); resultobj = Py_None;
37602 return resultobj;
37603 fail:
37604 return NULL;
37605 }
37606
37607
37608 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37609 PyObject *resultobj;
37610 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37611 int result;
37612 PyObject * obj0 = 0 ;
37613 char *kwnames[] = {
37614 (char *) "self", NULL
37615 };
37616
37617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
37618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37619 if (SWIG_arg_fail(1)) SWIG_fail;
37620 {
37621 PyThreadState* __tstate = wxPyBeginAllowThreads();
37622 result = (int)(arg1)->GetProportion();
37623
37624 wxPyEndAllowThreads(__tstate);
37625 if (PyErr_Occurred()) SWIG_fail;
37626 }
37627 {
37628 resultobj = SWIG_From_int((int)(result));
37629 }
37630 return resultobj;
37631 fail:
37632 return NULL;
37633 }
37634
37635
37636 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37637 PyObject *resultobj;
37638 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37639 int arg2 ;
37640 PyObject * obj0 = 0 ;
37641 PyObject * obj1 = 0 ;
37642 char *kwnames[] = {
37643 (char *) "self",(char *) "flag", NULL
37644 };
37645
37646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
37647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37648 if (SWIG_arg_fail(1)) SWIG_fail;
37649 {
37650 arg2 = (int)(SWIG_As_int(obj1));
37651 if (SWIG_arg_fail(2)) SWIG_fail;
37652 }
37653 {
37654 PyThreadState* __tstate = wxPyBeginAllowThreads();
37655 (arg1)->SetFlag(arg2);
37656
37657 wxPyEndAllowThreads(__tstate);
37658 if (PyErr_Occurred()) SWIG_fail;
37659 }
37660 Py_INCREF(Py_None); resultobj = Py_None;
37661 return resultobj;
37662 fail:
37663 return NULL;
37664 }
37665
37666
37667 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37668 PyObject *resultobj;
37669 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37670 int result;
37671 PyObject * obj0 = 0 ;
37672 char *kwnames[] = {
37673 (char *) "self", NULL
37674 };
37675
37676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
37677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37678 if (SWIG_arg_fail(1)) SWIG_fail;
37679 {
37680 PyThreadState* __tstate = wxPyBeginAllowThreads();
37681 result = (int)(arg1)->GetFlag();
37682
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 {
37687 resultobj = SWIG_From_int((int)(result));
37688 }
37689 return resultobj;
37690 fail:
37691 return NULL;
37692 }
37693
37694
37695 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37696 PyObject *resultobj;
37697 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37698 int arg2 ;
37699 PyObject * obj0 = 0 ;
37700 PyObject * obj1 = 0 ;
37701 char *kwnames[] = {
37702 (char *) "self",(char *) "border", NULL
37703 };
37704
37705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
37706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37707 if (SWIG_arg_fail(1)) SWIG_fail;
37708 {
37709 arg2 = (int)(SWIG_As_int(obj1));
37710 if (SWIG_arg_fail(2)) SWIG_fail;
37711 }
37712 {
37713 PyThreadState* __tstate = wxPyBeginAllowThreads();
37714 (arg1)->SetBorder(arg2);
37715
37716 wxPyEndAllowThreads(__tstate);
37717 if (PyErr_Occurred()) SWIG_fail;
37718 }
37719 Py_INCREF(Py_None); resultobj = Py_None;
37720 return resultobj;
37721 fail:
37722 return NULL;
37723 }
37724
37725
37726 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37727 PyObject *resultobj;
37728 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37729 int result;
37730 PyObject * obj0 = 0 ;
37731 char *kwnames[] = {
37732 (char *) "self", NULL
37733 };
37734
37735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
37736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37737 if (SWIG_arg_fail(1)) SWIG_fail;
37738 {
37739 PyThreadState* __tstate = wxPyBeginAllowThreads();
37740 result = (int)(arg1)->GetBorder();
37741
37742 wxPyEndAllowThreads(__tstate);
37743 if (PyErr_Occurred()) SWIG_fail;
37744 }
37745 {
37746 resultobj = SWIG_From_int((int)(result));
37747 }
37748 return resultobj;
37749 fail:
37750 return NULL;
37751 }
37752
37753
37754 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37755 PyObject *resultobj;
37756 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37757 wxWindow *result;
37758 PyObject * obj0 = 0 ;
37759 char *kwnames[] = {
37760 (char *) "self", NULL
37761 };
37762
37763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
37764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37765 if (SWIG_arg_fail(1)) SWIG_fail;
37766 {
37767 PyThreadState* __tstate = wxPyBeginAllowThreads();
37768 result = (wxWindow *)(arg1)->GetWindow();
37769
37770 wxPyEndAllowThreads(__tstate);
37771 if (PyErr_Occurred()) SWIG_fail;
37772 }
37773 {
37774 resultobj = wxPyMake_wxObject(result, 0);
37775 }
37776 return resultobj;
37777 fail:
37778 return NULL;
37779 }
37780
37781
37782 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37783 PyObject *resultobj;
37784 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37785 wxWindow *arg2 = (wxWindow *) 0 ;
37786 PyObject * obj0 = 0 ;
37787 PyObject * obj1 = 0 ;
37788 char *kwnames[] = {
37789 (char *) "self",(char *) "window", NULL
37790 };
37791
37792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
37793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37794 if (SWIG_arg_fail(1)) SWIG_fail;
37795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37796 if (SWIG_arg_fail(2)) SWIG_fail;
37797 {
37798 PyThreadState* __tstate = wxPyBeginAllowThreads();
37799 (arg1)->SetWindow(arg2);
37800
37801 wxPyEndAllowThreads(__tstate);
37802 if (PyErr_Occurred()) SWIG_fail;
37803 }
37804 Py_INCREF(Py_None); resultobj = Py_None;
37805 return resultobj;
37806 fail:
37807 return NULL;
37808 }
37809
37810
37811 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37812 PyObject *resultobj;
37813 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37814 wxSizer *result;
37815 PyObject * obj0 = 0 ;
37816 char *kwnames[] = {
37817 (char *) "self", NULL
37818 };
37819
37820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
37821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37822 if (SWIG_arg_fail(1)) SWIG_fail;
37823 {
37824 PyThreadState* __tstate = wxPyBeginAllowThreads();
37825 result = (wxSizer *)(arg1)->GetSizer();
37826
37827 wxPyEndAllowThreads(__tstate);
37828 if (PyErr_Occurred()) SWIG_fail;
37829 }
37830 {
37831 resultobj = wxPyMake_wxSizer(result, 0);
37832 }
37833 return resultobj;
37834 fail:
37835 return NULL;
37836 }
37837
37838
37839 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37840 PyObject *resultobj;
37841 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37842 wxSizer *arg2 = (wxSizer *) 0 ;
37843 PyObject * obj0 = 0 ;
37844 PyObject * obj1 = 0 ;
37845 char *kwnames[] = {
37846 (char *) "self",(char *) "sizer", NULL
37847 };
37848
37849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
37850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37851 if (SWIG_arg_fail(1)) SWIG_fail;
37852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37853 if (SWIG_arg_fail(2)) SWIG_fail;
37854 {
37855 PyThreadState* __tstate = wxPyBeginAllowThreads();
37856 (arg1)->SetSizer(arg2);
37857
37858 wxPyEndAllowThreads(__tstate);
37859 if (PyErr_Occurred()) SWIG_fail;
37860 }
37861 Py_INCREF(Py_None); resultobj = Py_None;
37862 return resultobj;
37863 fail:
37864 return NULL;
37865 }
37866
37867
37868 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37869 PyObject *resultobj;
37870 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37871 wxSize *result;
37872 PyObject * obj0 = 0 ;
37873 char *kwnames[] = {
37874 (char *) "self", NULL
37875 };
37876
37877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
37878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37879 if (SWIG_arg_fail(1)) SWIG_fail;
37880 {
37881 PyThreadState* __tstate = wxPyBeginAllowThreads();
37882 {
37883 wxSize const &_result_ref = (arg1)->GetSpacer();
37884 result = (wxSize *) &_result_ref;
37885 }
37886
37887 wxPyEndAllowThreads(__tstate);
37888 if (PyErr_Occurred()) SWIG_fail;
37889 }
37890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
37891 return resultobj;
37892 fail:
37893 return NULL;
37894 }
37895
37896
37897 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37898 PyObject *resultobj;
37899 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37900 wxSize *arg2 = 0 ;
37901 wxSize temp2 ;
37902 PyObject * obj0 = 0 ;
37903 PyObject * obj1 = 0 ;
37904 char *kwnames[] = {
37905 (char *) "self",(char *) "size", NULL
37906 };
37907
37908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
37909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37910 if (SWIG_arg_fail(1)) SWIG_fail;
37911 {
37912 arg2 = &temp2;
37913 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37914 }
37915 {
37916 PyThreadState* __tstate = wxPyBeginAllowThreads();
37917 (arg1)->SetSpacer((wxSize const &)*arg2);
37918
37919 wxPyEndAllowThreads(__tstate);
37920 if (PyErr_Occurred()) SWIG_fail;
37921 }
37922 Py_INCREF(Py_None); resultobj = Py_None;
37923 return resultobj;
37924 fail:
37925 return NULL;
37926 }
37927
37928
37929 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
37930 PyObject *resultobj;
37931 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37932 bool arg2 ;
37933 PyObject * obj0 = 0 ;
37934 PyObject * obj1 = 0 ;
37935 char *kwnames[] = {
37936 (char *) "self",(char *) "show", NULL
37937 };
37938
37939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
37940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37941 if (SWIG_arg_fail(1)) SWIG_fail;
37942 {
37943 arg2 = (bool)(SWIG_As_bool(obj1));
37944 if (SWIG_arg_fail(2)) SWIG_fail;
37945 }
37946 {
37947 PyThreadState* __tstate = wxPyBeginAllowThreads();
37948 (arg1)->Show(arg2);
37949
37950 wxPyEndAllowThreads(__tstate);
37951 if (PyErr_Occurred()) SWIG_fail;
37952 }
37953 Py_INCREF(Py_None); resultobj = Py_None;
37954 return resultobj;
37955 fail:
37956 return NULL;
37957 }
37958
37959
37960 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
37961 PyObject *resultobj;
37962 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37963 bool result;
37964 PyObject * obj0 = 0 ;
37965 char *kwnames[] = {
37966 (char *) "self", NULL
37967 };
37968
37969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
37970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37971 if (SWIG_arg_fail(1)) SWIG_fail;
37972 {
37973 PyThreadState* __tstate = wxPyBeginAllowThreads();
37974 result = (bool)(arg1)->IsShown();
37975
37976 wxPyEndAllowThreads(__tstate);
37977 if (PyErr_Occurred()) SWIG_fail;
37978 }
37979 {
37980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37981 }
37982 return resultobj;
37983 fail:
37984 return NULL;
37985 }
37986
37987
37988 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
37989 PyObject *resultobj;
37990 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37991 wxPoint result;
37992 PyObject * obj0 = 0 ;
37993 char *kwnames[] = {
37994 (char *) "self", NULL
37995 };
37996
37997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
37998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37999 if (SWIG_arg_fail(1)) SWIG_fail;
38000 {
38001 PyThreadState* __tstate = wxPyBeginAllowThreads();
38002 result = (arg1)->GetPosition();
38003
38004 wxPyEndAllowThreads(__tstate);
38005 if (PyErr_Occurred()) SWIG_fail;
38006 }
38007 {
38008 wxPoint * resultptr;
38009 resultptr = new wxPoint((wxPoint &)(result));
38010 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38011 }
38012 return resultobj;
38013 fail:
38014 return NULL;
38015 }
38016
38017
38018 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38019 PyObject *resultobj;
38020 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38021 PyObject *result;
38022 PyObject * obj0 = 0 ;
38023 char *kwnames[] = {
38024 (char *) "self", NULL
38025 };
38026
38027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38029 if (SWIG_arg_fail(1)) SWIG_fail;
38030 {
38031 PyThreadState* __tstate = wxPyBeginAllowThreads();
38032 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38033
38034 wxPyEndAllowThreads(__tstate);
38035 if (PyErr_Occurred()) SWIG_fail;
38036 }
38037 resultobj = result;
38038 return resultobj;
38039 fail:
38040 return NULL;
38041 }
38042
38043
38044 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38045 PyObject *obj;
38046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38047 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38048 Py_INCREF(obj);
38049 return Py_BuildValue((char *)"");
38050 }
38051 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38052 PyObject *resultobj;
38053 wxSizer *arg1 = (wxSizer *) 0 ;
38054 PyObject *arg2 = (PyObject *) 0 ;
38055 PyObject * obj0 = 0 ;
38056 PyObject * obj1 = 0 ;
38057 char *kwnames[] = {
38058 (char *) "self",(char *) "_self", NULL
38059 };
38060
38061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38063 if (SWIG_arg_fail(1)) SWIG_fail;
38064 arg2 = obj1;
38065 {
38066 PyThreadState* __tstate = wxPyBeginAllowThreads();
38067 wxSizer__setOORInfo(arg1,arg2);
38068
38069 wxPyEndAllowThreads(__tstate);
38070 if (PyErr_Occurred()) SWIG_fail;
38071 }
38072 Py_INCREF(Py_None); resultobj = Py_None;
38073 return resultobj;
38074 fail:
38075 return NULL;
38076 }
38077
38078
38079 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38080 PyObject *resultobj;
38081 wxSizer *arg1 = (wxSizer *) 0 ;
38082 PyObject *arg2 = (PyObject *) 0 ;
38083 int arg3 = (int) 0 ;
38084 int arg4 = (int) 0 ;
38085 int arg5 = (int) 0 ;
38086 PyObject *arg6 = (PyObject *) NULL ;
38087 wxSizerItem *result;
38088 PyObject * obj0 = 0 ;
38089 PyObject * obj1 = 0 ;
38090 PyObject * obj2 = 0 ;
38091 PyObject * obj3 = 0 ;
38092 PyObject * obj4 = 0 ;
38093 PyObject * obj5 = 0 ;
38094 char *kwnames[] = {
38095 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38096 };
38097
38098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38100 if (SWIG_arg_fail(1)) SWIG_fail;
38101 arg2 = obj1;
38102 if (obj2) {
38103 {
38104 arg3 = (int)(SWIG_As_int(obj2));
38105 if (SWIG_arg_fail(3)) SWIG_fail;
38106 }
38107 }
38108 if (obj3) {
38109 {
38110 arg4 = (int)(SWIG_As_int(obj3));
38111 if (SWIG_arg_fail(4)) SWIG_fail;
38112 }
38113 }
38114 if (obj4) {
38115 {
38116 arg5 = (int)(SWIG_As_int(obj4));
38117 if (SWIG_arg_fail(5)) SWIG_fail;
38118 }
38119 }
38120 if (obj5) {
38121 arg6 = obj5;
38122 }
38123 {
38124 PyThreadState* __tstate = wxPyBeginAllowThreads();
38125 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
38126
38127 wxPyEndAllowThreads(__tstate);
38128 if (PyErr_Occurred()) SWIG_fail;
38129 }
38130 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38131 return resultobj;
38132 fail:
38133 return NULL;
38134 }
38135
38136
38137 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38138 PyObject *resultobj;
38139 wxSizer *arg1 = (wxSizer *) 0 ;
38140 int arg2 ;
38141 PyObject *arg3 = (PyObject *) 0 ;
38142 int arg4 = (int) 0 ;
38143 int arg5 = (int) 0 ;
38144 int arg6 = (int) 0 ;
38145 PyObject *arg7 = (PyObject *) NULL ;
38146 wxSizerItem *result;
38147 PyObject * obj0 = 0 ;
38148 PyObject * obj1 = 0 ;
38149 PyObject * obj2 = 0 ;
38150 PyObject * obj3 = 0 ;
38151 PyObject * obj4 = 0 ;
38152 PyObject * obj5 = 0 ;
38153 PyObject * obj6 = 0 ;
38154 char *kwnames[] = {
38155 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38156 };
38157
38158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38160 if (SWIG_arg_fail(1)) SWIG_fail;
38161 {
38162 arg2 = (int)(SWIG_As_int(obj1));
38163 if (SWIG_arg_fail(2)) SWIG_fail;
38164 }
38165 arg3 = obj2;
38166 if (obj3) {
38167 {
38168 arg4 = (int)(SWIG_As_int(obj3));
38169 if (SWIG_arg_fail(4)) SWIG_fail;
38170 }
38171 }
38172 if (obj4) {
38173 {
38174 arg5 = (int)(SWIG_As_int(obj4));
38175 if (SWIG_arg_fail(5)) SWIG_fail;
38176 }
38177 }
38178 if (obj5) {
38179 {
38180 arg6 = (int)(SWIG_As_int(obj5));
38181 if (SWIG_arg_fail(6)) SWIG_fail;
38182 }
38183 }
38184 if (obj6) {
38185 arg7 = obj6;
38186 }
38187 {
38188 PyThreadState* __tstate = wxPyBeginAllowThreads();
38189 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
38190
38191 wxPyEndAllowThreads(__tstate);
38192 if (PyErr_Occurred()) SWIG_fail;
38193 }
38194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38195 return resultobj;
38196 fail:
38197 return NULL;
38198 }
38199
38200
38201 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
38202 PyObject *resultobj;
38203 wxSizer *arg1 = (wxSizer *) 0 ;
38204 PyObject *arg2 = (PyObject *) 0 ;
38205 int arg3 = (int) 0 ;
38206 int arg4 = (int) 0 ;
38207 int arg5 = (int) 0 ;
38208 PyObject *arg6 = (PyObject *) NULL ;
38209 wxSizerItem *result;
38210 PyObject * obj0 = 0 ;
38211 PyObject * obj1 = 0 ;
38212 PyObject * obj2 = 0 ;
38213 PyObject * obj3 = 0 ;
38214 PyObject * obj4 = 0 ;
38215 PyObject * obj5 = 0 ;
38216 char *kwnames[] = {
38217 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38218 };
38219
38220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38222 if (SWIG_arg_fail(1)) SWIG_fail;
38223 arg2 = obj1;
38224 if (obj2) {
38225 {
38226 arg3 = (int)(SWIG_As_int(obj2));
38227 if (SWIG_arg_fail(3)) SWIG_fail;
38228 }
38229 }
38230 if (obj3) {
38231 {
38232 arg4 = (int)(SWIG_As_int(obj3));
38233 if (SWIG_arg_fail(4)) SWIG_fail;
38234 }
38235 }
38236 if (obj4) {
38237 {
38238 arg5 = (int)(SWIG_As_int(obj4));
38239 if (SWIG_arg_fail(5)) SWIG_fail;
38240 }
38241 }
38242 if (obj5) {
38243 arg6 = obj5;
38244 }
38245 {
38246 PyThreadState* __tstate = wxPyBeginAllowThreads();
38247 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
38248
38249 wxPyEndAllowThreads(__tstate);
38250 if (PyErr_Occurred()) SWIG_fail;
38251 }
38252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38253 return resultobj;
38254 fail:
38255 return NULL;
38256 }
38257
38258
38259 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
38260 PyObject *resultobj;
38261 wxSizer *arg1 = (wxSizer *) 0 ;
38262 PyObject *arg2 = (PyObject *) 0 ;
38263 bool result;
38264 PyObject * obj0 = 0 ;
38265 PyObject * obj1 = 0 ;
38266 char *kwnames[] = {
38267 (char *) "self",(char *) "item", NULL
38268 };
38269
38270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
38271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38272 if (SWIG_arg_fail(1)) SWIG_fail;
38273 arg2 = obj1;
38274 {
38275 PyThreadState* __tstate = wxPyBeginAllowThreads();
38276 result = (bool)wxSizer_Remove(arg1,arg2);
38277
38278 wxPyEndAllowThreads(__tstate);
38279 if (PyErr_Occurred()) SWIG_fail;
38280 }
38281 {
38282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38283 }
38284 return resultobj;
38285 fail:
38286 return NULL;
38287 }
38288
38289
38290 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
38291 PyObject *resultobj;
38292 wxSizer *arg1 = (wxSizer *) 0 ;
38293 PyObject *arg2 = (PyObject *) 0 ;
38294 bool result;
38295 PyObject * obj0 = 0 ;
38296 PyObject * obj1 = 0 ;
38297 char *kwnames[] = {
38298 (char *) "self",(char *) "item", NULL
38299 };
38300
38301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
38302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38303 if (SWIG_arg_fail(1)) SWIG_fail;
38304 arg2 = obj1;
38305 {
38306 PyThreadState* __tstate = wxPyBeginAllowThreads();
38307 result = (bool)wxSizer_Detach(arg1,arg2);
38308
38309 wxPyEndAllowThreads(__tstate);
38310 if (PyErr_Occurred()) SWIG_fail;
38311 }
38312 {
38313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38314 }
38315 return resultobj;
38316 fail:
38317 return NULL;
38318 }
38319
38320
38321 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
38322 PyObject *resultobj;
38323 wxSizer *arg1 = (wxSizer *) 0 ;
38324 PyObject *arg2 = (PyObject *) 0 ;
38325 wxSizerItem *result;
38326 PyObject * obj0 = 0 ;
38327 PyObject * obj1 = 0 ;
38328 char *kwnames[] = {
38329 (char *) "self",(char *) "item", NULL
38330 };
38331
38332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
38333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38334 if (SWIG_arg_fail(1)) SWIG_fail;
38335 arg2 = obj1;
38336 {
38337 PyThreadState* __tstate = wxPyBeginAllowThreads();
38338 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
38339
38340 wxPyEndAllowThreads(__tstate);
38341 if (PyErr_Occurred()) SWIG_fail;
38342 }
38343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38344 return resultobj;
38345 fail:
38346 return NULL;
38347 }
38348
38349
38350 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38351 PyObject *resultobj;
38352 wxSizer *arg1 = (wxSizer *) 0 ;
38353 PyObject *arg2 = (PyObject *) 0 ;
38354 wxSize *arg3 = 0 ;
38355 wxSize temp3 ;
38356 PyObject * obj0 = 0 ;
38357 PyObject * obj1 = 0 ;
38358 PyObject * obj2 = 0 ;
38359 char *kwnames[] = {
38360 (char *) "self",(char *) "item",(char *) "size", NULL
38361 };
38362
38363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38365 if (SWIG_arg_fail(1)) SWIG_fail;
38366 arg2 = obj1;
38367 {
38368 arg3 = &temp3;
38369 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
38370 }
38371 {
38372 PyThreadState* __tstate = wxPyBeginAllowThreads();
38373 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
38374
38375 wxPyEndAllowThreads(__tstate);
38376 if (PyErr_Occurred()) SWIG_fail;
38377 }
38378 Py_INCREF(Py_None); resultobj = Py_None;
38379 return resultobj;
38380 fail:
38381 return NULL;
38382 }
38383
38384
38385 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
38386 PyObject *resultobj;
38387 wxSizer *arg1 = (wxSizer *) 0 ;
38388 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38389 wxSizerItem *result;
38390 PyObject * obj0 = 0 ;
38391 PyObject * obj1 = 0 ;
38392 char *kwnames[] = {
38393 (char *) "self",(char *) "item", NULL
38394 };
38395
38396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
38397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38398 if (SWIG_arg_fail(1)) SWIG_fail;
38399 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38400 if (SWIG_arg_fail(2)) SWIG_fail;
38401 {
38402 PyThreadState* __tstate = wxPyBeginAllowThreads();
38403 result = (wxSizerItem *)(arg1)->Add(arg2);
38404
38405 wxPyEndAllowThreads(__tstate);
38406 if (PyErr_Occurred()) SWIG_fail;
38407 }
38408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38409 return resultobj;
38410 fail:
38411 return NULL;
38412 }
38413
38414
38415 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
38416 PyObject *resultobj;
38417 wxSizer *arg1 = (wxSizer *) 0 ;
38418 size_t arg2 ;
38419 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
38420 wxSizerItem *result;
38421 PyObject * obj0 = 0 ;
38422 PyObject * obj1 = 0 ;
38423 PyObject * obj2 = 0 ;
38424 char *kwnames[] = {
38425 (char *) "self",(char *) "index",(char *) "item", NULL
38426 };
38427
38428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
38429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38430 if (SWIG_arg_fail(1)) SWIG_fail;
38431 {
38432 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
38433 if (SWIG_arg_fail(2)) SWIG_fail;
38434 }
38435 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38436 if (SWIG_arg_fail(3)) SWIG_fail;
38437 {
38438 PyThreadState* __tstate = wxPyBeginAllowThreads();
38439 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
38440
38441 wxPyEndAllowThreads(__tstate);
38442 if (PyErr_Occurred()) SWIG_fail;
38443 }
38444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38445 return resultobj;
38446 fail:
38447 return NULL;
38448 }
38449
38450
38451 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
38452 PyObject *resultobj;
38453 wxSizer *arg1 = (wxSizer *) 0 ;
38454 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38455 wxSizerItem *result;
38456 PyObject * obj0 = 0 ;
38457 PyObject * obj1 = 0 ;
38458 char *kwnames[] = {
38459 (char *) "self",(char *) "item", NULL
38460 };
38461
38462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
38463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38464 if (SWIG_arg_fail(1)) SWIG_fail;
38465 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38466 if (SWIG_arg_fail(2)) SWIG_fail;
38467 {
38468 PyThreadState* __tstate = wxPyBeginAllowThreads();
38469 result = (wxSizerItem *)(arg1)->Prepend(arg2);
38470
38471 wxPyEndAllowThreads(__tstate);
38472 if (PyErr_Occurred()) SWIG_fail;
38473 }
38474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38475 return resultobj;
38476 fail:
38477 return NULL;
38478 }
38479
38480
38481 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38482 PyObject *resultobj;
38483 wxSizer *arg1 = (wxSizer *) 0 ;
38484 int arg2 ;
38485 int arg3 ;
38486 int arg4 ;
38487 int arg5 ;
38488 PyObject * obj0 = 0 ;
38489 PyObject * obj1 = 0 ;
38490 PyObject * obj2 = 0 ;
38491 PyObject * obj3 = 0 ;
38492 PyObject * obj4 = 0 ;
38493 char *kwnames[] = {
38494 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
38495 };
38496
38497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38499 if (SWIG_arg_fail(1)) SWIG_fail;
38500 {
38501 arg2 = (int)(SWIG_As_int(obj1));
38502 if (SWIG_arg_fail(2)) SWIG_fail;
38503 }
38504 {
38505 arg3 = (int)(SWIG_As_int(obj2));
38506 if (SWIG_arg_fail(3)) SWIG_fail;
38507 }
38508 {
38509 arg4 = (int)(SWIG_As_int(obj3));
38510 if (SWIG_arg_fail(4)) SWIG_fail;
38511 }
38512 {
38513 arg5 = (int)(SWIG_As_int(obj4));
38514 if (SWIG_arg_fail(5)) SWIG_fail;
38515 }
38516 {
38517 PyThreadState* __tstate = wxPyBeginAllowThreads();
38518 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
38519
38520 wxPyEndAllowThreads(__tstate);
38521 if (PyErr_Occurred()) SWIG_fail;
38522 }
38523 Py_INCREF(Py_None); resultobj = Py_None;
38524 return resultobj;
38525 fail:
38526 return NULL;
38527 }
38528
38529
38530 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38531 PyObject *resultobj;
38532 wxSizer *arg1 = (wxSizer *) 0 ;
38533 wxSize *arg2 = 0 ;
38534 wxSize temp2 ;
38535 PyObject * obj0 = 0 ;
38536 PyObject * obj1 = 0 ;
38537 char *kwnames[] = {
38538 (char *) "self",(char *) "size", NULL
38539 };
38540
38541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
38542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38543 if (SWIG_arg_fail(1)) SWIG_fail;
38544 {
38545 arg2 = &temp2;
38546 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38547 }
38548 {
38549 PyThreadState* __tstate = wxPyBeginAllowThreads();
38550 (arg1)->SetMinSize((wxSize const &)*arg2);
38551
38552 wxPyEndAllowThreads(__tstate);
38553 if (PyErr_Occurred()) SWIG_fail;
38554 }
38555 Py_INCREF(Py_None); resultobj = Py_None;
38556 return resultobj;
38557 fail:
38558 return NULL;
38559 }
38560
38561
38562 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38563 PyObject *resultobj;
38564 wxSizer *arg1 = (wxSizer *) 0 ;
38565 wxSize result;
38566 PyObject * obj0 = 0 ;
38567 char *kwnames[] = {
38568 (char *) "self", NULL
38569 };
38570
38571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
38572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38573 if (SWIG_arg_fail(1)) SWIG_fail;
38574 {
38575 PyThreadState* __tstate = wxPyBeginAllowThreads();
38576 result = (arg1)->GetSize();
38577
38578 wxPyEndAllowThreads(__tstate);
38579 if (PyErr_Occurred()) SWIG_fail;
38580 }
38581 {
38582 wxSize * resultptr;
38583 resultptr = new wxSize((wxSize &)(result));
38584 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38585 }
38586 return resultobj;
38587 fail:
38588 return NULL;
38589 }
38590
38591
38592 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38593 PyObject *resultobj;
38594 wxSizer *arg1 = (wxSizer *) 0 ;
38595 wxPoint result;
38596 PyObject * obj0 = 0 ;
38597 char *kwnames[] = {
38598 (char *) "self", NULL
38599 };
38600
38601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
38602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38603 if (SWIG_arg_fail(1)) SWIG_fail;
38604 {
38605 PyThreadState* __tstate = wxPyBeginAllowThreads();
38606 result = (arg1)->GetPosition();
38607
38608 wxPyEndAllowThreads(__tstate);
38609 if (PyErr_Occurred()) SWIG_fail;
38610 }
38611 {
38612 wxPoint * resultptr;
38613 resultptr = new wxPoint((wxPoint &)(result));
38614 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38615 }
38616 return resultobj;
38617 fail:
38618 return NULL;
38619 }
38620
38621
38622 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38623 PyObject *resultobj;
38624 wxSizer *arg1 = (wxSizer *) 0 ;
38625 wxSize result;
38626 PyObject * obj0 = 0 ;
38627 char *kwnames[] = {
38628 (char *) "self", NULL
38629 };
38630
38631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
38632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38633 if (SWIG_arg_fail(1)) SWIG_fail;
38634 {
38635 PyThreadState* __tstate = wxPyBeginAllowThreads();
38636 result = (arg1)->GetMinSize();
38637
38638 wxPyEndAllowThreads(__tstate);
38639 if (PyErr_Occurred()) SWIG_fail;
38640 }
38641 {
38642 wxSize * resultptr;
38643 resultptr = new wxSize((wxSize &)(result));
38644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38645 }
38646 return resultobj;
38647 fail:
38648 return NULL;
38649 }
38650
38651
38652 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
38653 PyObject *resultobj;
38654 wxSizer *arg1 = (wxSizer *) 0 ;
38655 PyObject * obj0 = 0 ;
38656 char *kwnames[] = {
38657 (char *) "self", NULL
38658 };
38659
38660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
38661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38662 if (SWIG_arg_fail(1)) SWIG_fail;
38663 {
38664 PyThreadState* __tstate = wxPyBeginAllowThreads();
38665 (arg1)->RecalcSizes();
38666
38667 wxPyEndAllowThreads(__tstate);
38668 if (PyErr_Occurred()) SWIG_fail;
38669 }
38670 Py_INCREF(Py_None); resultobj = Py_None;
38671 return resultobj;
38672 fail:
38673 return NULL;
38674 }
38675
38676
38677 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38678 PyObject *resultobj;
38679 wxSizer *arg1 = (wxSizer *) 0 ;
38680 wxSize result;
38681 PyObject * obj0 = 0 ;
38682 char *kwnames[] = {
38683 (char *) "self", NULL
38684 };
38685
38686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
38687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38688 if (SWIG_arg_fail(1)) SWIG_fail;
38689 {
38690 PyThreadState* __tstate = wxPyBeginAllowThreads();
38691 result = (arg1)->CalcMin();
38692
38693 wxPyEndAllowThreads(__tstate);
38694 if (PyErr_Occurred()) SWIG_fail;
38695 }
38696 {
38697 wxSize * resultptr;
38698 resultptr = new wxSize((wxSize &)(result));
38699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38700 }
38701 return resultobj;
38702 fail:
38703 return NULL;
38704 }
38705
38706
38707 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
38708 PyObject *resultobj;
38709 wxSizer *arg1 = (wxSizer *) 0 ;
38710 PyObject * obj0 = 0 ;
38711 char *kwnames[] = {
38712 (char *) "self", NULL
38713 };
38714
38715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
38716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38717 if (SWIG_arg_fail(1)) SWIG_fail;
38718 {
38719 PyThreadState* __tstate = wxPyBeginAllowThreads();
38720 (arg1)->Layout();
38721
38722 wxPyEndAllowThreads(__tstate);
38723 if (PyErr_Occurred()) SWIG_fail;
38724 }
38725 Py_INCREF(Py_None); resultobj = Py_None;
38726 return resultobj;
38727 fail:
38728 return NULL;
38729 }
38730
38731
38732 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
38733 PyObject *resultobj;
38734 wxSizer *arg1 = (wxSizer *) 0 ;
38735 wxWindow *arg2 = (wxWindow *) 0 ;
38736 wxSize result;
38737 PyObject * obj0 = 0 ;
38738 PyObject * obj1 = 0 ;
38739 char *kwnames[] = {
38740 (char *) "self",(char *) "window", NULL
38741 };
38742
38743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
38744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38745 if (SWIG_arg_fail(1)) SWIG_fail;
38746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38747 if (SWIG_arg_fail(2)) SWIG_fail;
38748 {
38749 PyThreadState* __tstate = wxPyBeginAllowThreads();
38750 result = (arg1)->Fit(arg2);
38751
38752 wxPyEndAllowThreads(__tstate);
38753 if (PyErr_Occurred()) SWIG_fail;
38754 }
38755 {
38756 wxSize * resultptr;
38757 resultptr = new wxSize((wxSize &)(result));
38758 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38759 }
38760 return resultobj;
38761 fail:
38762 return NULL;
38763 }
38764
38765
38766 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
38767 PyObject *resultobj;
38768 wxSizer *arg1 = (wxSizer *) 0 ;
38769 wxWindow *arg2 = (wxWindow *) 0 ;
38770 PyObject * obj0 = 0 ;
38771 PyObject * obj1 = 0 ;
38772 char *kwnames[] = {
38773 (char *) "self",(char *) "window", NULL
38774 };
38775
38776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
38777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38778 if (SWIG_arg_fail(1)) SWIG_fail;
38779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38780 if (SWIG_arg_fail(2)) SWIG_fail;
38781 {
38782 PyThreadState* __tstate = wxPyBeginAllowThreads();
38783 (arg1)->FitInside(arg2);
38784
38785 wxPyEndAllowThreads(__tstate);
38786 if (PyErr_Occurred()) SWIG_fail;
38787 }
38788 Py_INCREF(Py_None); resultobj = Py_None;
38789 return resultobj;
38790 fail:
38791 return NULL;
38792 }
38793
38794
38795 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
38796 PyObject *resultobj;
38797 wxSizer *arg1 = (wxSizer *) 0 ;
38798 wxWindow *arg2 = (wxWindow *) 0 ;
38799 PyObject * obj0 = 0 ;
38800 PyObject * obj1 = 0 ;
38801 char *kwnames[] = {
38802 (char *) "self",(char *) "window", NULL
38803 };
38804
38805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
38806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38807 if (SWIG_arg_fail(1)) SWIG_fail;
38808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38809 if (SWIG_arg_fail(2)) SWIG_fail;
38810 {
38811 PyThreadState* __tstate = wxPyBeginAllowThreads();
38812 (arg1)->SetSizeHints(arg2);
38813
38814 wxPyEndAllowThreads(__tstate);
38815 if (PyErr_Occurred()) SWIG_fail;
38816 }
38817 Py_INCREF(Py_None); resultobj = Py_None;
38818 return resultobj;
38819 fail:
38820 return NULL;
38821 }
38822
38823
38824 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
38825 PyObject *resultobj;
38826 wxSizer *arg1 = (wxSizer *) 0 ;
38827 wxWindow *arg2 = (wxWindow *) 0 ;
38828 PyObject * obj0 = 0 ;
38829 PyObject * obj1 = 0 ;
38830 char *kwnames[] = {
38831 (char *) "self",(char *) "window", NULL
38832 };
38833
38834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
38835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38836 if (SWIG_arg_fail(1)) SWIG_fail;
38837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38838 if (SWIG_arg_fail(2)) SWIG_fail;
38839 {
38840 PyThreadState* __tstate = wxPyBeginAllowThreads();
38841 (arg1)->SetVirtualSizeHints(arg2);
38842
38843 wxPyEndAllowThreads(__tstate);
38844 if (PyErr_Occurred()) SWIG_fail;
38845 }
38846 Py_INCREF(Py_None); resultobj = Py_None;
38847 return resultobj;
38848 fail:
38849 return NULL;
38850 }
38851
38852
38853 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38854 PyObject *resultobj;
38855 wxSizer *arg1 = (wxSizer *) 0 ;
38856 bool arg2 = (bool) false ;
38857 PyObject * obj0 = 0 ;
38858 PyObject * obj1 = 0 ;
38859 char *kwnames[] = {
38860 (char *) "self",(char *) "deleteWindows", NULL
38861 };
38862
38863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
38864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38865 if (SWIG_arg_fail(1)) SWIG_fail;
38866 if (obj1) {
38867 {
38868 arg2 = (bool)(SWIG_As_bool(obj1));
38869 if (SWIG_arg_fail(2)) SWIG_fail;
38870 }
38871 }
38872 {
38873 PyThreadState* __tstate = wxPyBeginAllowThreads();
38874 (arg1)->Clear(arg2);
38875
38876 wxPyEndAllowThreads(__tstate);
38877 if (PyErr_Occurred()) SWIG_fail;
38878 }
38879 Py_INCREF(Py_None); resultobj = Py_None;
38880 return resultobj;
38881 fail:
38882 return NULL;
38883 }
38884
38885
38886 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38887 PyObject *resultobj;
38888 wxSizer *arg1 = (wxSizer *) 0 ;
38889 PyObject * obj0 = 0 ;
38890 char *kwnames[] = {
38891 (char *) "self", NULL
38892 };
38893
38894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
38895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38896 if (SWIG_arg_fail(1)) SWIG_fail;
38897 {
38898 PyThreadState* __tstate = wxPyBeginAllowThreads();
38899 (arg1)->DeleteWindows();
38900
38901 wxPyEndAllowThreads(__tstate);
38902 if (PyErr_Occurred()) SWIG_fail;
38903 }
38904 Py_INCREF(Py_None); resultobj = Py_None;
38905 return resultobj;
38906 fail:
38907 return NULL;
38908 }
38909
38910
38911 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
38912 PyObject *resultobj;
38913 wxSizer *arg1 = (wxSizer *) 0 ;
38914 PyObject *result;
38915 PyObject * obj0 = 0 ;
38916 char *kwnames[] = {
38917 (char *) "self", NULL
38918 };
38919
38920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
38921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38922 if (SWIG_arg_fail(1)) SWIG_fail;
38923 {
38924 PyThreadState* __tstate = wxPyBeginAllowThreads();
38925 result = (PyObject *)wxSizer_GetChildren(arg1);
38926
38927 wxPyEndAllowThreads(__tstate);
38928 if (PyErr_Occurred()) SWIG_fail;
38929 }
38930 resultobj = result;
38931 return resultobj;
38932 fail:
38933 return NULL;
38934 }
38935
38936
38937 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38938 PyObject *resultobj;
38939 wxSizer *arg1 = (wxSizer *) 0 ;
38940 PyObject *arg2 = (PyObject *) 0 ;
38941 bool arg3 = (bool) true ;
38942 bool arg4 = (bool) false ;
38943 bool result;
38944 PyObject * obj0 = 0 ;
38945 PyObject * obj1 = 0 ;
38946 PyObject * obj2 = 0 ;
38947 PyObject * obj3 = 0 ;
38948 char *kwnames[] = {
38949 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
38950 };
38951
38952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38954 if (SWIG_arg_fail(1)) SWIG_fail;
38955 arg2 = obj1;
38956 if (obj2) {
38957 {
38958 arg3 = (bool)(SWIG_As_bool(obj2));
38959 if (SWIG_arg_fail(3)) SWIG_fail;
38960 }
38961 }
38962 if (obj3) {
38963 {
38964 arg4 = (bool)(SWIG_As_bool(obj3));
38965 if (SWIG_arg_fail(4)) SWIG_fail;
38966 }
38967 }
38968 {
38969 PyThreadState* __tstate = wxPyBeginAllowThreads();
38970 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
38971
38972 wxPyEndAllowThreads(__tstate);
38973 if (PyErr_Occurred()) SWIG_fail;
38974 }
38975 {
38976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38977 }
38978 return resultobj;
38979 fail:
38980 return NULL;
38981 }
38982
38983
38984 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38985 PyObject *resultobj;
38986 wxSizer *arg1 = (wxSizer *) 0 ;
38987 PyObject *arg2 = (PyObject *) 0 ;
38988 bool result;
38989 PyObject * obj0 = 0 ;
38990 PyObject * obj1 = 0 ;
38991 char *kwnames[] = {
38992 (char *) "self",(char *) "item", NULL
38993 };
38994
38995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
38996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38997 if (SWIG_arg_fail(1)) SWIG_fail;
38998 arg2 = obj1;
38999 {
39000 PyThreadState* __tstate = wxPyBeginAllowThreads();
39001 result = (bool)wxSizer_IsShown(arg1,arg2);
39002
39003 wxPyEndAllowThreads(__tstate);
39004 if (PyErr_Occurred()) SWIG_fail;
39005 }
39006 {
39007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39008 }
39009 return resultobj;
39010 fail:
39011 return NULL;
39012 }
39013
39014
39015 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39016 PyObject *resultobj;
39017 wxSizer *arg1 = (wxSizer *) 0 ;
39018 bool arg2 ;
39019 PyObject * obj0 = 0 ;
39020 PyObject * obj1 = 0 ;
39021 char *kwnames[] = {
39022 (char *) "self",(char *) "show", NULL
39023 };
39024
39025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39027 if (SWIG_arg_fail(1)) SWIG_fail;
39028 {
39029 arg2 = (bool)(SWIG_As_bool(obj1));
39030 if (SWIG_arg_fail(2)) SWIG_fail;
39031 }
39032 {
39033 PyThreadState* __tstate = wxPyBeginAllowThreads();
39034 (arg1)->ShowItems(arg2);
39035
39036 wxPyEndAllowThreads(__tstate);
39037 if (PyErr_Occurred()) SWIG_fail;
39038 }
39039 Py_INCREF(Py_None); resultobj = Py_None;
39040 return resultobj;
39041 fail:
39042 return NULL;
39043 }
39044
39045
39046 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39047 PyObject *obj;
39048 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39049 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39050 Py_INCREF(obj);
39051 return Py_BuildValue((char *)"");
39052 }
39053 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39054 PyObject *resultobj;
39055 wxPySizer *result;
39056 char *kwnames[] = {
39057 NULL
39058 };
39059
39060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39061 {
39062 PyThreadState* __tstate = wxPyBeginAllowThreads();
39063 result = (wxPySizer *)new wxPySizer();
39064
39065 wxPyEndAllowThreads(__tstate);
39066 if (PyErr_Occurred()) SWIG_fail;
39067 }
39068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39069 return resultobj;
39070 fail:
39071 return NULL;
39072 }
39073
39074
39075 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39076 PyObject *resultobj;
39077 wxPySizer *arg1 = (wxPySizer *) 0 ;
39078 PyObject *arg2 = (PyObject *) 0 ;
39079 PyObject *arg3 = (PyObject *) 0 ;
39080 PyObject * obj0 = 0 ;
39081 PyObject * obj1 = 0 ;
39082 PyObject * obj2 = 0 ;
39083 char *kwnames[] = {
39084 (char *) "self",(char *) "self",(char *) "_class", NULL
39085 };
39086
39087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
39088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
39089 if (SWIG_arg_fail(1)) SWIG_fail;
39090 arg2 = obj1;
39091 arg3 = obj2;
39092 {
39093 PyThreadState* __tstate = wxPyBeginAllowThreads();
39094 (arg1)->_setCallbackInfo(arg2,arg3);
39095
39096 wxPyEndAllowThreads(__tstate);
39097 if (PyErr_Occurred()) SWIG_fail;
39098 }
39099 Py_INCREF(Py_None); resultobj = Py_None;
39100 return resultobj;
39101 fail:
39102 return NULL;
39103 }
39104
39105
39106 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
39107 PyObject *obj;
39108 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39109 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
39110 Py_INCREF(obj);
39111 return Py_BuildValue((char *)"");
39112 }
39113 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39114 PyObject *resultobj;
39115 int arg1 = (int) wxHORIZONTAL ;
39116 wxBoxSizer *result;
39117 PyObject * obj0 = 0 ;
39118 char *kwnames[] = {
39119 (char *) "orient", NULL
39120 };
39121
39122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
39123 if (obj0) {
39124 {
39125 arg1 = (int)(SWIG_As_int(obj0));
39126 if (SWIG_arg_fail(1)) SWIG_fail;
39127 }
39128 }
39129 {
39130 PyThreadState* __tstate = wxPyBeginAllowThreads();
39131 result = (wxBoxSizer *)new wxBoxSizer(arg1);
39132
39133 wxPyEndAllowThreads(__tstate);
39134 if (PyErr_Occurred()) SWIG_fail;
39135 }
39136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
39137 return resultobj;
39138 fail:
39139 return NULL;
39140 }
39141
39142
39143 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39144 PyObject *resultobj;
39145 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39146 int result;
39147 PyObject * obj0 = 0 ;
39148 char *kwnames[] = {
39149 (char *) "self", NULL
39150 };
39151
39152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
39153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39154 if (SWIG_arg_fail(1)) SWIG_fail;
39155 {
39156 PyThreadState* __tstate = wxPyBeginAllowThreads();
39157 result = (int)(arg1)->GetOrientation();
39158
39159 wxPyEndAllowThreads(__tstate);
39160 if (PyErr_Occurred()) SWIG_fail;
39161 }
39162 {
39163 resultobj = SWIG_From_int((int)(result));
39164 }
39165 return resultobj;
39166 fail:
39167 return NULL;
39168 }
39169
39170
39171 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39172 PyObject *resultobj;
39173 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39174 int arg2 ;
39175 PyObject * obj0 = 0 ;
39176 PyObject * obj1 = 0 ;
39177 char *kwnames[] = {
39178 (char *) "self",(char *) "orient", NULL
39179 };
39180
39181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
39182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39183 if (SWIG_arg_fail(1)) SWIG_fail;
39184 {
39185 arg2 = (int)(SWIG_As_int(obj1));
39186 if (SWIG_arg_fail(2)) SWIG_fail;
39187 }
39188 {
39189 PyThreadState* __tstate = wxPyBeginAllowThreads();
39190 (arg1)->SetOrientation(arg2);
39191
39192 wxPyEndAllowThreads(__tstate);
39193 if (PyErr_Occurred()) SWIG_fail;
39194 }
39195 Py_INCREF(Py_None); resultobj = Py_None;
39196 return resultobj;
39197 fail:
39198 return NULL;
39199 }
39200
39201
39202 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
39203 PyObject *obj;
39204 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39205 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
39206 Py_INCREF(obj);
39207 return Py_BuildValue((char *)"");
39208 }
39209 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39210 PyObject *resultobj;
39211 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
39212 int arg2 = (int) wxHORIZONTAL ;
39213 wxStaticBoxSizer *result;
39214 PyObject * obj0 = 0 ;
39215 PyObject * obj1 = 0 ;
39216 char *kwnames[] = {
39217 (char *) "box",(char *) "orient", NULL
39218 };
39219
39220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
39221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
39222 if (SWIG_arg_fail(1)) SWIG_fail;
39223 if (obj1) {
39224 {
39225 arg2 = (int)(SWIG_As_int(obj1));
39226 if (SWIG_arg_fail(2)) SWIG_fail;
39227 }
39228 }
39229 {
39230 PyThreadState* __tstate = wxPyBeginAllowThreads();
39231 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
39232
39233 wxPyEndAllowThreads(__tstate);
39234 if (PyErr_Occurred()) SWIG_fail;
39235 }
39236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
39237 return resultobj;
39238 fail:
39239 return NULL;
39240 }
39241
39242
39243 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
39244 PyObject *resultobj;
39245 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
39246 wxStaticBox *result;
39247 PyObject * obj0 = 0 ;
39248 char *kwnames[] = {
39249 (char *) "self", NULL
39250 };
39251
39252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
39253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39254 if (SWIG_arg_fail(1)) SWIG_fail;
39255 {
39256 PyThreadState* __tstate = wxPyBeginAllowThreads();
39257 result = (wxStaticBox *)(arg1)->GetStaticBox();
39258
39259 wxPyEndAllowThreads(__tstate);
39260 if (PyErr_Occurred()) SWIG_fail;
39261 }
39262 {
39263 resultobj = wxPyMake_wxObject(result, 0);
39264 }
39265 return resultobj;
39266 fail:
39267 return NULL;
39268 }
39269
39270
39271 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
39272 PyObject *obj;
39273 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39274 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
39275 Py_INCREF(obj);
39276 return Py_BuildValue((char *)"");
39277 }
39278 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39279 PyObject *resultobj;
39280 int arg1 = (int) 1 ;
39281 int arg2 = (int) 0 ;
39282 int arg3 = (int) 0 ;
39283 int arg4 = (int) 0 ;
39284 wxGridSizer *result;
39285 PyObject * obj0 = 0 ;
39286 PyObject * obj1 = 0 ;
39287 PyObject * obj2 = 0 ;
39288 PyObject * obj3 = 0 ;
39289 char *kwnames[] = {
39290 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39291 };
39292
39293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39294 if (obj0) {
39295 {
39296 arg1 = (int)(SWIG_As_int(obj0));
39297 if (SWIG_arg_fail(1)) SWIG_fail;
39298 }
39299 }
39300 if (obj1) {
39301 {
39302 arg2 = (int)(SWIG_As_int(obj1));
39303 if (SWIG_arg_fail(2)) SWIG_fail;
39304 }
39305 }
39306 if (obj2) {
39307 {
39308 arg3 = (int)(SWIG_As_int(obj2));
39309 if (SWIG_arg_fail(3)) SWIG_fail;
39310 }
39311 }
39312 if (obj3) {
39313 {
39314 arg4 = (int)(SWIG_As_int(obj3));
39315 if (SWIG_arg_fail(4)) SWIG_fail;
39316 }
39317 }
39318 {
39319 PyThreadState* __tstate = wxPyBeginAllowThreads();
39320 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
39321
39322 wxPyEndAllowThreads(__tstate);
39323 if (PyErr_Occurred()) SWIG_fail;
39324 }
39325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
39326 return resultobj;
39327 fail:
39328 return NULL;
39329 }
39330
39331
39332 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39333 PyObject *resultobj;
39334 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39335 int arg2 ;
39336 PyObject * obj0 = 0 ;
39337 PyObject * obj1 = 0 ;
39338 char *kwnames[] = {
39339 (char *) "self",(char *) "cols", NULL
39340 };
39341
39342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
39343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39344 if (SWIG_arg_fail(1)) SWIG_fail;
39345 {
39346 arg2 = (int)(SWIG_As_int(obj1));
39347 if (SWIG_arg_fail(2)) SWIG_fail;
39348 }
39349 {
39350 PyThreadState* __tstate = wxPyBeginAllowThreads();
39351 (arg1)->SetCols(arg2);
39352
39353 wxPyEndAllowThreads(__tstate);
39354 if (PyErr_Occurred()) SWIG_fail;
39355 }
39356 Py_INCREF(Py_None); resultobj = Py_None;
39357 return resultobj;
39358 fail:
39359 return NULL;
39360 }
39361
39362
39363 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39364 PyObject *resultobj;
39365 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39366 int arg2 ;
39367 PyObject * obj0 = 0 ;
39368 PyObject * obj1 = 0 ;
39369 char *kwnames[] = {
39370 (char *) "self",(char *) "rows", NULL
39371 };
39372
39373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
39374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39375 if (SWIG_arg_fail(1)) SWIG_fail;
39376 {
39377 arg2 = (int)(SWIG_As_int(obj1));
39378 if (SWIG_arg_fail(2)) SWIG_fail;
39379 }
39380 {
39381 PyThreadState* __tstate = wxPyBeginAllowThreads();
39382 (arg1)->SetRows(arg2);
39383
39384 wxPyEndAllowThreads(__tstate);
39385 if (PyErr_Occurred()) SWIG_fail;
39386 }
39387 Py_INCREF(Py_None); resultobj = Py_None;
39388 return resultobj;
39389 fail:
39390 return NULL;
39391 }
39392
39393
39394 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39395 PyObject *resultobj;
39396 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39397 int arg2 ;
39398 PyObject * obj0 = 0 ;
39399 PyObject * obj1 = 0 ;
39400 char *kwnames[] = {
39401 (char *) "self",(char *) "gap", NULL
39402 };
39403
39404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
39405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39406 if (SWIG_arg_fail(1)) SWIG_fail;
39407 {
39408 arg2 = (int)(SWIG_As_int(obj1));
39409 if (SWIG_arg_fail(2)) SWIG_fail;
39410 }
39411 {
39412 PyThreadState* __tstate = wxPyBeginAllowThreads();
39413 (arg1)->SetVGap(arg2);
39414
39415 wxPyEndAllowThreads(__tstate);
39416 if (PyErr_Occurred()) SWIG_fail;
39417 }
39418 Py_INCREF(Py_None); resultobj = Py_None;
39419 return resultobj;
39420 fail:
39421 return NULL;
39422 }
39423
39424
39425 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39426 PyObject *resultobj;
39427 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39428 int arg2 ;
39429 PyObject * obj0 = 0 ;
39430 PyObject * obj1 = 0 ;
39431 char *kwnames[] = {
39432 (char *) "self",(char *) "gap", NULL
39433 };
39434
39435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
39436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39437 if (SWIG_arg_fail(1)) SWIG_fail;
39438 {
39439 arg2 = (int)(SWIG_As_int(obj1));
39440 if (SWIG_arg_fail(2)) SWIG_fail;
39441 }
39442 {
39443 PyThreadState* __tstate = wxPyBeginAllowThreads();
39444 (arg1)->SetHGap(arg2);
39445
39446 wxPyEndAllowThreads(__tstate);
39447 if (PyErr_Occurred()) SWIG_fail;
39448 }
39449 Py_INCREF(Py_None); resultobj = Py_None;
39450 return resultobj;
39451 fail:
39452 return NULL;
39453 }
39454
39455
39456 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39457 PyObject *resultobj;
39458 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39459 int result;
39460 PyObject * obj0 = 0 ;
39461 char *kwnames[] = {
39462 (char *) "self", NULL
39463 };
39464
39465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
39466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39467 if (SWIG_arg_fail(1)) SWIG_fail;
39468 {
39469 PyThreadState* __tstate = wxPyBeginAllowThreads();
39470 result = (int)(arg1)->GetCols();
39471
39472 wxPyEndAllowThreads(__tstate);
39473 if (PyErr_Occurred()) SWIG_fail;
39474 }
39475 {
39476 resultobj = SWIG_From_int((int)(result));
39477 }
39478 return resultobj;
39479 fail:
39480 return NULL;
39481 }
39482
39483
39484 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39485 PyObject *resultobj;
39486 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39487 int result;
39488 PyObject * obj0 = 0 ;
39489 char *kwnames[] = {
39490 (char *) "self", NULL
39491 };
39492
39493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
39494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39495 if (SWIG_arg_fail(1)) SWIG_fail;
39496 {
39497 PyThreadState* __tstate = wxPyBeginAllowThreads();
39498 result = (int)(arg1)->GetRows();
39499
39500 wxPyEndAllowThreads(__tstate);
39501 if (PyErr_Occurred()) SWIG_fail;
39502 }
39503 {
39504 resultobj = SWIG_From_int((int)(result));
39505 }
39506 return resultobj;
39507 fail:
39508 return NULL;
39509 }
39510
39511
39512 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39513 PyObject *resultobj;
39514 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39515 int result;
39516 PyObject * obj0 = 0 ;
39517 char *kwnames[] = {
39518 (char *) "self", NULL
39519 };
39520
39521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
39522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39523 if (SWIG_arg_fail(1)) SWIG_fail;
39524 {
39525 PyThreadState* __tstate = wxPyBeginAllowThreads();
39526 result = (int)(arg1)->GetVGap();
39527
39528 wxPyEndAllowThreads(__tstate);
39529 if (PyErr_Occurred()) SWIG_fail;
39530 }
39531 {
39532 resultobj = SWIG_From_int((int)(result));
39533 }
39534 return resultobj;
39535 fail:
39536 return NULL;
39537 }
39538
39539
39540 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39541 PyObject *resultobj;
39542 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39543 int result;
39544 PyObject * obj0 = 0 ;
39545 char *kwnames[] = {
39546 (char *) "self", NULL
39547 };
39548
39549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
39550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39551 if (SWIG_arg_fail(1)) SWIG_fail;
39552 {
39553 PyThreadState* __tstate = wxPyBeginAllowThreads();
39554 result = (int)(arg1)->GetHGap();
39555
39556 wxPyEndAllowThreads(__tstate);
39557 if (PyErr_Occurred()) SWIG_fail;
39558 }
39559 {
39560 resultobj = SWIG_From_int((int)(result));
39561 }
39562 return resultobj;
39563 fail:
39564 return NULL;
39565 }
39566
39567
39568 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
39569 PyObject *obj;
39570 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39571 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
39572 Py_INCREF(obj);
39573 return Py_BuildValue((char *)"");
39574 }
39575 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39576 PyObject *resultobj;
39577 int arg1 = (int) 1 ;
39578 int arg2 = (int) 0 ;
39579 int arg3 = (int) 0 ;
39580 int arg4 = (int) 0 ;
39581 wxFlexGridSizer *result;
39582 PyObject * obj0 = 0 ;
39583 PyObject * obj1 = 0 ;
39584 PyObject * obj2 = 0 ;
39585 PyObject * obj3 = 0 ;
39586 char *kwnames[] = {
39587 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39588 };
39589
39590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39591 if (obj0) {
39592 {
39593 arg1 = (int)(SWIG_As_int(obj0));
39594 if (SWIG_arg_fail(1)) SWIG_fail;
39595 }
39596 }
39597 if (obj1) {
39598 {
39599 arg2 = (int)(SWIG_As_int(obj1));
39600 if (SWIG_arg_fail(2)) SWIG_fail;
39601 }
39602 }
39603 if (obj2) {
39604 {
39605 arg3 = (int)(SWIG_As_int(obj2));
39606 if (SWIG_arg_fail(3)) SWIG_fail;
39607 }
39608 }
39609 if (obj3) {
39610 {
39611 arg4 = (int)(SWIG_As_int(obj3));
39612 if (SWIG_arg_fail(4)) SWIG_fail;
39613 }
39614 }
39615 {
39616 PyThreadState* __tstate = wxPyBeginAllowThreads();
39617 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
39618
39619 wxPyEndAllowThreads(__tstate);
39620 if (PyErr_Occurred()) SWIG_fail;
39621 }
39622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
39623 return resultobj;
39624 fail:
39625 return NULL;
39626 }
39627
39628
39629 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39630 PyObject *resultobj;
39631 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39632 size_t arg2 ;
39633 int arg3 = (int) 0 ;
39634 PyObject * obj0 = 0 ;
39635 PyObject * obj1 = 0 ;
39636 PyObject * obj2 = 0 ;
39637 char *kwnames[] = {
39638 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39639 };
39640
39641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
39642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39643 if (SWIG_arg_fail(1)) SWIG_fail;
39644 {
39645 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39646 if (SWIG_arg_fail(2)) SWIG_fail;
39647 }
39648 if (obj2) {
39649 {
39650 arg3 = (int)(SWIG_As_int(obj2));
39651 if (SWIG_arg_fail(3)) SWIG_fail;
39652 }
39653 }
39654 {
39655 PyThreadState* __tstate = wxPyBeginAllowThreads();
39656 (arg1)->AddGrowableRow(arg2,arg3);
39657
39658 wxPyEndAllowThreads(__tstate);
39659 if (PyErr_Occurred()) SWIG_fail;
39660 }
39661 Py_INCREF(Py_None); resultobj = Py_None;
39662 return resultobj;
39663 fail:
39664 return NULL;
39665 }
39666
39667
39668 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39669 PyObject *resultobj;
39670 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39671 size_t arg2 ;
39672 PyObject * obj0 = 0 ;
39673 PyObject * obj1 = 0 ;
39674 char *kwnames[] = {
39675 (char *) "self",(char *) "idx", NULL
39676 };
39677
39678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
39679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39680 if (SWIG_arg_fail(1)) SWIG_fail;
39681 {
39682 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39683 if (SWIG_arg_fail(2)) SWIG_fail;
39684 }
39685 {
39686 PyThreadState* __tstate = wxPyBeginAllowThreads();
39687 (arg1)->RemoveGrowableRow(arg2);
39688
39689 wxPyEndAllowThreads(__tstate);
39690 if (PyErr_Occurred()) SWIG_fail;
39691 }
39692 Py_INCREF(Py_None); resultobj = Py_None;
39693 return resultobj;
39694 fail:
39695 return NULL;
39696 }
39697
39698
39699 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
39700 PyObject *resultobj;
39701 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39702 size_t arg2 ;
39703 int arg3 = (int) 0 ;
39704 PyObject * obj0 = 0 ;
39705 PyObject * obj1 = 0 ;
39706 PyObject * obj2 = 0 ;
39707 char *kwnames[] = {
39708 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39709 };
39710
39711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
39712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39713 if (SWIG_arg_fail(1)) SWIG_fail;
39714 {
39715 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39716 if (SWIG_arg_fail(2)) SWIG_fail;
39717 }
39718 if (obj2) {
39719 {
39720 arg3 = (int)(SWIG_As_int(obj2));
39721 if (SWIG_arg_fail(3)) SWIG_fail;
39722 }
39723 }
39724 {
39725 PyThreadState* __tstate = wxPyBeginAllowThreads();
39726 (arg1)->AddGrowableCol(arg2,arg3);
39727
39728 wxPyEndAllowThreads(__tstate);
39729 if (PyErr_Occurred()) SWIG_fail;
39730 }
39731 Py_INCREF(Py_None); resultobj = Py_None;
39732 return resultobj;
39733 fail:
39734 return NULL;
39735 }
39736
39737
39738 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
39739 PyObject *resultobj;
39740 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39741 size_t arg2 ;
39742 PyObject * obj0 = 0 ;
39743 PyObject * obj1 = 0 ;
39744 char *kwnames[] = {
39745 (char *) "self",(char *) "idx", NULL
39746 };
39747
39748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
39749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39750 if (SWIG_arg_fail(1)) SWIG_fail;
39751 {
39752 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39753 if (SWIG_arg_fail(2)) SWIG_fail;
39754 }
39755 {
39756 PyThreadState* __tstate = wxPyBeginAllowThreads();
39757 (arg1)->RemoveGrowableCol(arg2);
39758
39759 wxPyEndAllowThreads(__tstate);
39760 if (PyErr_Occurred()) SWIG_fail;
39761 }
39762 Py_INCREF(Py_None); resultobj = Py_None;
39763 return resultobj;
39764 fail:
39765 return NULL;
39766 }
39767
39768
39769 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
39770 PyObject *resultobj;
39771 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39772 int arg2 ;
39773 PyObject * obj0 = 0 ;
39774 PyObject * obj1 = 0 ;
39775 char *kwnames[] = {
39776 (char *) "self",(char *) "direction", NULL
39777 };
39778
39779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
39780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39781 if (SWIG_arg_fail(1)) SWIG_fail;
39782 {
39783 arg2 = (int)(SWIG_As_int(obj1));
39784 if (SWIG_arg_fail(2)) SWIG_fail;
39785 }
39786 {
39787 PyThreadState* __tstate = wxPyBeginAllowThreads();
39788 (arg1)->SetFlexibleDirection(arg2);
39789
39790 wxPyEndAllowThreads(__tstate);
39791 if (PyErr_Occurred()) SWIG_fail;
39792 }
39793 Py_INCREF(Py_None); resultobj = Py_None;
39794 return resultobj;
39795 fail:
39796 return NULL;
39797 }
39798
39799
39800 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
39801 PyObject *resultobj;
39802 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39803 int result;
39804 PyObject * obj0 = 0 ;
39805 char *kwnames[] = {
39806 (char *) "self", NULL
39807 };
39808
39809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
39810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39811 if (SWIG_arg_fail(1)) SWIG_fail;
39812 {
39813 PyThreadState* __tstate = wxPyBeginAllowThreads();
39814 result = (int)(arg1)->GetFlexibleDirection();
39815
39816 wxPyEndAllowThreads(__tstate);
39817 if (PyErr_Occurred()) SWIG_fail;
39818 }
39819 {
39820 resultobj = SWIG_From_int((int)(result));
39821 }
39822 return resultobj;
39823 fail:
39824 return NULL;
39825 }
39826
39827
39828 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
39829 PyObject *resultobj;
39830 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39831 wxFlexSizerGrowMode arg2 ;
39832 PyObject * obj0 = 0 ;
39833 PyObject * obj1 = 0 ;
39834 char *kwnames[] = {
39835 (char *) "self",(char *) "mode", NULL
39836 };
39837
39838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
39839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39840 if (SWIG_arg_fail(1)) SWIG_fail;
39841 {
39842 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
39843 if (SWIG_arg_fail(2)) SWIG_fail;
39844 }
39845 {
39846 PyThreadState* __tstate = wxPyBeginAllowThreads();
39847 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
39848
39849 wxPyEndAllowThreads(__tstate);
39850 if (PyErr_Occurred()) SWIG_fail;
39851 }
39852 Py_INCREF(Py_None); resultobj = Py_None;
39853 return resultobj;
39854 fail:
39855 return NULL;
39856 }
39857
39858
39859 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
39860 PyObject *resultobj;
39861 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39862 wxFlexSizerGrowMode result;
39863 PyObject * obj0 = 0 ;
39864 char *kwnames[] = {
39865 (char *) "self", NULL
39866 };
39867
39868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
39869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39870 if (SWIG_arg_fail(1)) SWIG_fail;
39871 {
39872 PyThreadState* __tstate = wxPyBeginAllowThreads();
39873 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
39874
39875 wxPyEndAllowThreads(__tstate);
39876 if (PyErr_Occurred()) SWIG_fail;
39877 }
39878 resultobj = SWIG_From_int((result));
39879 return resultobj;
39880 fail:
39881 return NULL;
39882 }
39883
39884
39885 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
39886 PyObject *resultobj;
39887 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39888 wxArrayInt *result;
39889 PyObject * obj0 = 0 ;
39890 char *kwnames[] = {
39891 (char *) "self", NULL
39892 };
39893
39894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
39895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39896 if (SWIG_arg_fail(1)) SWIG_fail;
39897 {
39898 PyThreadState* __tstate = wxPyBeginAllowThreads();
39899 {
39900 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
39901 result = (wxArrayInt *) &_result_ref;
39902 }
39903
39904 wxPyEndAllowThreads(__tstate);
39905 if (PyErr_Occurred()) SWIG_fail;
39906 }
39907 {
39908 resultobj = PyList_New(0);
39909 size_t idx;
39910 for (idx = 0; idx < result->GetCount(); idx += 1) {
39911 PyObject* val = PyInt_FromLong( result->Item(idx) );
39912 PyList_Append(resultobj, val);
39913 Py_DECREF(val);
39914 }
39915 }
39916 return resultobj;
39917 fail:
39918 return NULL;
39919 }
39920
39921
39922 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
39923 PyObject *resultobj;
39924 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39925 wxArrayInt *result;
39926 PyObject * obj0 = 0 ;
39927 char *kwnames[] = {
39928 (char *) "self", NULL
39929 };
39930
39931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
39932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39933 if (SWIG_arg_fail(1)) SWIG_fail;
39934 {
39935 PyThreadState* __tstate = wxPyBeginAllowThreads();
39936 {
39937 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
39938 result = (wxArrayInt *) &_result_ref;
39939 }
39940
39941 wxPyEndAllowThreads(__tstate);
39942 if (PyErr_Occurred()) SWIG_fail;
39943 }
39944 {
39945 resultobj = PyList_New(0);
39946 size_t idx;
39947 for (idx = 0; idx < result->GetCount(); idx += 1) {
39948 PyObject* val = PyInt_FromLong( result->Item(idx) );
39949 PyList_Append(resultobj, val);
39950 Py_DECREF(val);
39951 }
39952 }
39953 return resultobj;
39954 fail:
39955 return NULL;
39956 }
39957
39958
39959 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
39960 PyObject *obj;
39961 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39962 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
39963 Py_INCREF(obj);
39964 return Py_BuildValue((char *)"");
39965 }
39966 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39967 PyObject *resultobj;
39968 wxStdDialogButtonSizer *result;
39969 char *kwnames[] = {
39970 NULL
39971 };
39972
39973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
39974 {
39975 PyThreadState* __tstate = wxPyBeginAllowThreads();
39976 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
39977
39978 wxPyEndAllowThreads(__tstate);
39979 if (PyErr_Occurred()) SWIG_fail;
39980 }
39981 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
39982 return resultobj;
39983 fail:
39984 return NULL;
39985 }
39986
39987
39988 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
39989 PyObject *resultobj;
39990 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
39991 wxButton *arg2 = (wxButton *) 0 ;
39992 PyObject * obj0 = 0 ;
39993 PyObject * obj1 = 0 ;
39994 char *kwnames[] = {
39995 (char *) "self",(char *) "button", NULL
39996 };
39997
39998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
39999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40000 if (SWIG_arg_fail(1)) SWIG_fail;
40001 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40002 if (SWIG_arg_fail(2)) SWIG_fail;
40003 {
40004 PyThreadState* __tstate = wxPyBeginAllowThreads();
40005 (arg1)->AddButton(arg2);
40006
40007 wxPyEndAllowThreads(__tstate);
40008 if (PyErr_Occurred()) SWIG_fail;
40009 }
40010 Py_INCREF(Py_None); resultobj = Py_None;
40011 return resultobj;
40012 fail:
40013 return NULL;
40014 }
40015
40016
40017 static PyObject *_wrap_StdDialogButtonSizer_Finalise(PyObject *, PyObject *args, PyObject *kwargs) {
40018 PyObject *resultobj;
40019 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40020 PyObject * obj0 = 0 ;
40021 char *kwnames[] = {
40022 (char *) "self", NULL
40023 };
40024
40025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Finalise",kwnames,&obj0)) goto fail;
40026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40027 if (SWIG_arg_fail(1)) SWIG_fail;
40028 {
40029 PyThreadState* __tstate = wxPyBeginAllowThreads();
40030 (arg1)->Finalise();
40031
40032 wxPyEndAllowThreads(__tstate);
40033 if (PyErr_Occurred()) SWIG_fail;
40034 }
40035 Py_INCREF(Py_None); resultobj = Py_None;
40036 return resultobj;
40037 fail:
40038 return NULL;
40039 }
40040
40041
40042 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40043 PyObject *resultobj;
40044 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40045 wxButton *arg2 = (wxButton *) 0 ;
40046 PyObject * obj0 = 0 ;
40047 PyObject * obj1 = 0 ;
40048 char *kwnames[] = {
40049 (char *) "self",(char *) "button", NULL
40050 };
40051
40052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
40053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40054 if (SWIG_arg_fail(1)) SWIG_fail;
40055 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40056 if (SWIG_arg_fail(2)) SWIG_fail;
40057 {
40058 PyThreadState* __tstate = wxPyBeginAllowThreads();
40059 (arg1)->SetAffirmativeButton(arg2);
40060
40061 wxPyEndAllowThreads(__tstate);
40062 if (PyErr_Occurred()) SWIG_fail;
40063 }
40064 Py_INCREF(Py_None); resultobj = Py_None;
40065 return resultobj;
40066 fail:
40067 return NULL;
40068 }
40069
40070
40071 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40072 PyObject *resultobj;
40073 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40074 wxButton *arg2 = (wxButton *) 0 ;
40075 PyObject * obj0 = 0 ;
40076 PyObject * obj1 = 0 ;
40077 char *kwnames[] = {
40078 (char *) "self",(char *) "button", NULL
40079 };
40080
40081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
40082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40083 if (SWIG_arg_fail(1)) SWIG_fail;
40084 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40085 if (SWIG_arg_fail(2)) SWIG_fail;
40086 {
40087 PyThreadState* __tstate = wxPyBeginAllowThreads();
40088 (arg1)->SetNegativeButton(arg2);
40089
40090 wxPyEndAllowThreads(__tstate);
40091 if (PyErr_Occurred()) SWIG_fail;
40092 }
40093 Py_INCREF(Py_None); resultobj = Py_None;
40094 return resultobj;
40095 fail:
40096 return NULL;
40097 }
40098
40099
40100 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40101 PyObject *resultobj;
40102 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40103 wxButton *arg2 = (wxButton *) 0 ;
40104 PyObject * obj0 = 0 ;
40105 PyObject * obj1 = 0 ;
40106 char *kwnames[] = {
40107 (char *) "self",(char *) "button", NULL
40108 };
40109
40110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
40111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40112 if (SWIG_arg_fail(1)) SWIG_fail;
40113 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40114 if (SWIG_arg_fail(2)) SWIG_fail;
40115 {
40116 PyThreadState* __tstate = wxPyBeginAllowThreads();
40117 (arg1)->SetCancelButton(arg2);
40118
40119 wxPyEndAllowThreads(__tstate);
40120 if (PyErr_Occurred()) SWIG_fail;
40121 }
40122 Py_INCREF(Py_None); resultobj = Py_None;
40123 return resultobj;
40124 fail:
40125 return NULL;
40126 }
40127
40128
40129 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40130 PyObject *resultobj;
40131 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40132 wxButton *result;
40133 PyObject * obj0 = 0 ;
40134 char *kwnames[] = {
40135 (char *) "self", NULL
40136 };
40137
40138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
40139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40140 if (SWIG_arg_fail(1)) SWIG_fail;
40141 {
40142 PyThreadState* __tstate = wxPyBeginAllowThreads();
40143 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
40144
40145 wxPyEndAllowThreads(__tstate);
40146 if (PyErr_Occurred()) SWIG_fail;
40147 }
40148 {
40149 resultobj = wxPyMake_wxObject(result, 0);
40150 }
40151 return resultobj;
40152 fail:
40153 return NULL;
40154 }
40155
40156
40157 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
40158 PyObject *resultobj;
40159 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40160 wxButton *result;
40161 PyObject * obj0 = 0 ;
40162 char *kwnames[] = {
40163 (char *) "self", NULL
40164 };
40165
40166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
40167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40168 if (SWIG_arg_fail(1)) SWIG_fail;
40169 {
40170 PyThreadState* __tstate = wxPyBeginAllowThreads();
40171 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
40172
40173 wxPyEndAllowThreads(__tstate);
40174 if (PyErr_Occurred()) SWIG_fail;
40175 }
40176 {
40177 resultobj = wxPyMake_wxObject(result, 0);
40178 }
40179 return resultobj;
40180 fail:
40181 return NULL;
40182 }
40183
40184
40185 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40186 PyObject *resultobj;
40187 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40188 wxButton *result;
40189 PyObject * obj0 = 0 ;
40190 char *kwnames[] = {
40191 (char *) "self", NULL
40192 };
40193
40194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
40195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40196 if (SWIG_arg_fail(1)) SWIG_fail;
40197 {
40198 PyThreadState* __tstate = wxPyBeginAllowThreads();
40199 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
40200
40201 wxPyEndAllowThreads(__tstate);
40202 if (PyErr_Occurred()) SWIG_fail;
40203 }
40204 {
40205 resultobj = wxPyMake_wxObject(result, 0);
40206 }
40207 return resultobj;
40208 fail:
40209 return NULL;
40210 }
40211
40212
40213 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40214 PyObject *resultobj;
40215 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40216 wxButton *result;
40217 PyObject * obj0 = 0 ;
40218 char *kwnames[] = {
40219 (char *) "self", NULL
40220 };
40221
40222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
40223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40224 if (SWIG_arg_fail(1)) SWIG_fail;
40225 {
40226 PyThreadState* __tstate = wxPyBeginAllowThreads();
40227 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
40228
40229 wxPyEndAllowThreads(__tstate);
40230 if (PyErr_Occurred()) SWIG_fail;
40231 }
40232 {
40233 resultobj = wxPyMake_wxObject(result, 0);
40234 }
40235 return resultobj;
40236 fail:
40237 return NULL;
40238 }
40239
40240
40241 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
40242 PyObject *resultobj;
40243 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40244 wxButton *result;
40245 PyObject * obj0 = 0 ;
40246 char *kwnames[] = {
40247 (char *) "self", NULL
40248 };
40249
40250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
40251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40252 if (SWIG_arg_fail(1)) SWIG_fail;
40253 {
40254 PyThreadState* __tstate = wxPyBeginAllowThreads();
40255 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
40256
40257 wxPyEndAllowThreads(__tstate);
40258 if (PyErr_Occurred()) SWIG_fail;
40259 }
40260 {
40261 resultobj = wxPyMake_wxObject(result, 0);
40262 }
40263 return resultobj;
40264 fail:
40265 return NULL;
40266 }
40267
40268
40269 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
40270 PyObject *obj;
40271 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40272 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
40273 Py_INCREF(obj);
40274 return Py_BuildValue((char *)"");
40275 }
40276 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40277 PyObject *resultobj;
40278 int arg1 = (int) 0 ;
40279 int arg2 = (int) 0 ;
40280 wxGBPosition *result;
40281 PyObject * obj0 = 0 ;
40282 PyObject * obj1 = 0 ;
40283 char *kwnames[] = {
40284 (char *) "row",(char *) "col", NULL
40285 };
40286
40287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
40288 if (obj0) {
40289 {
40290 arg1 = (int)(SWIG_As_int(obj0));
40291 if (SWIG_arg_fail(1)) SWIG_fail;
40292 }
40293 }
40294 if (obj1) {
40295 {
40296 arg2 = (int)(SWIG_As_int(obj1));
40297 if (SWIG_arg_fail(2)) SWIG_fail;
40298 }
40299 }
40300 {
40301 PyThreadState* __tstate = wxPyBeginAllowThreads();
40302 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
40303
40304 wxPyEndAllowThreads(__tstate);
40305 if (PyErr_Occurred()) SWIG_fail;
40306 }
40307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
40308 return resultobj;
40309 fail:
40310 return NULL;
40311 }
40312
40313
40314 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40315 PyObject *resultobj;
40316 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40317 int result;
40318 PyObject * obj0 = 0 ;
40319 char *kwnames[] = {
40320 (char *) "self", NULL
40321 };
40322
40323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
40324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40325 if (SWIG_arg_fail(1)) SWIG_fail;
40326 {
40327 PyThreadState* __tstate = wxPyBeginAllowThreads();
40328 result = (int)((wxGBPosition const *)arg1)->GetRow();
40329
40330 wxPyEndAllowThreads(__tstate);
40331 if (PyErr_Occurred()) SWIG_fail;
40332 }
40333 {
40334 resultobj = SWIG_From_int((int)(result));
40335 }
40336 return resultobj;
40337 fail:
40338 return NULL;
40339 }
40340
40341
40342 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40343 PyObject *resultobj;
40344 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40345 int result;
40346 PyObject * obj0 = 0 ;
40347 char *kwnames[] = {
40348 (char *) "self", NULL
40349 };
40350
40351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
40352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40353 if (SWIG_arg_fail(1)) SWIG_fail;
40354 {
40355 PyThreadState* __tstate = wxPyBeginAllowThreads();
40356 result = (int)((wxGBPosition const *)arg1)->GetCol();
40357
40358 wxPyEndAllowThreads(__tstate);
40359 if (PyErr_Occurred()) SWIG_fail;
40360 }
40361 {
40362 resultobj = SWIG_From_int((int)(result));
40363 }
40364 return resultobj;
40365 fail:
40366 return NULL;
40367 }
40368
40369
40370 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40371 PyObject *resultobj;
40372 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40373 int arg2 ;
40374 PyObject * obj0 = 0 ;
40375 PyObject * obj1 = 0 ;
40376 char *kwnames[] = {
40377 (char *) "self",(char *) "row", NULL
40378 };
40379
40380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
40381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40382 if (SWIG_arg_fail(1)) SWIG_fail;
40383 {
40384 arg2 = (int)(SWIG_As_int(obj1));
40385 if (SWIG_arg_fail(2)) SWIG_fail;
40386 }
40387 {
40388 PyThreadState* __tstate = wxPyBeginAllowThreads();
40389 (arg1)->SetRow(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_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40402 PyObject *resultobj;
40403 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40404 int arg2 ;
40405 PyObject * obj0 = 0 ;
40406 PyObject * obj1 = 0 ;
40407 char *kwnames[] = {
40408 (char *) "self",(char *) "col", NULL
40409 };
40410
40411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
40412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40413 if (SWIG_arg_fail(1)) SWIG_fail;
40414 {
40415 arg2 = (int)(SWIG_As_int(obj1));
40416 if (SWIG_arg_fail(2)) SWIG_fail;
40417 }
40418 {
40419 PyThreadState* __tstate = wxPyBeginAllowThreads();
40420 (arg1)->SetCol(arg2);
40421
40422 wxPyEndAllowThreads(__tstate);
40423 if (PyErr_Occurred()) SWIG_fail;
40424 }
40425 Py_INCREF(Py_None); resultobj = Py_None;
40426 return resultobj;
40427 fail:
40428 return NULL;
40429 }
40430
40431
40432 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40433 PyObject *resultobj;
40434 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40435 wxGBPosition *arg2 = 0 ;
40436 bool result;
40437 wxGBPosition temp2 ;
40438 PyObject * obj0 = 0 ;
40439 PyObject * obj1 = 0 ;
40440 char *kwnames[] = {
40441 (char *) "self",(char *) "other", NULL
40442 };
40443
40444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
40445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40446 if (SWIG_arg_fail(1)) SWIG_fail;
40447 {
40448 arg2 = &temp2;
40449 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40450 }
40451 {
40452 PyThreadState* __tstate = wxPyBeginAllowThreads();
40453 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
40454
40455 wxPyEndAllowThreads(__tstate);
40456 if (PyErr_Occurred()) SWIG_fail;
40457 }
40458 {
40459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40460 }
40461 return resultobj;
40462 fail:
40463 return NULL;
40464 }
40465
40466
40467 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40468 PyObject *resultobj;
40469 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40470 wxGBPosition *arg2 = 0 ;
40471 bool result;
40472 wxGBPosition temp2 ;
40473 PyObject * obj0 = 0 ;
40474 PyObject * obj1 = 0 ;
40475 char *kwnames[] = {
40476 (char *) "self",(char *) "other", NULL
40477 };
40478
40479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
40480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40481 if (SWIG_arg_fail(1)) SWIG_fail;
40482 {
40483 arg2 = &temp2;
40484 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40485 }
40486 {
40487 PyThreadState* __tstate = wxPyBeginAllowThreads();
40488 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
40489
40490 wxPyEndAllowThreads(__tstate);
40491 if (PyErr_Occurred()) SWIG_fail;
40492 }
40493 {
40494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40495 }
40496 return resultobj;
40497 fail:
40498 return NULL;
40499 }
40500
40501
40502 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40503 PyObject *resultobj;
40504 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40505 int arg2 = (int) 0 ;
40506 int arg3 = (int) 0 ;
40507 PyObject * obj0 = 0 ;
40508 PyObject * obj1 = 0 ;
40509 PyObject * obj2 = 0 ;
40510 char *kwnames[] = {
40511 (char *) "self",(char *) "row",(char *) "col", NULL
40512 };
40513
40514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40516 if (SWIG_arg_fail(1)) SWIG_fail;
40517 if (obj1) {
40518 {
40519 arg2 = (int)(SWIG_As_int(obj1));
40520 if (SWIG_arg_fail(2)) SWIG_fail;
40521 }
40522 }
40523 if (obj2) {
40524 {
40525 arg3 = (int)(SWIG_As_int(obj2));
40526 if (SWIG_arg_fail(3)) SWIG_fail;
40527 }
40528 }
40529 {
40530 PyThreadState* __tstate = wxPyBeginAllowThreads();
40531 wxGBPosition_Set(arg1,arg2,arg3);
40532
40533 wxPyEndAllowThreads(__tstate);
40534 if (PyErr_Occurred()) SWIG_fail;
40535 }
40536 Py_INCREF(Py_None); resultobj = Py_None;
40537 return resultobj;
40538 fail:
40539 return NULL;
40540 }
40541
40542
40543 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40544 PyObject *resultobj;
40545 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40546 PyObject *result;
40547 PyObject * obj0 = 0 ;
40548 char *kwnames[] = {
40549 (char *) "self", NULL
40550 };
40551
40552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
40553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40554 if (SWIG_arg_fail(1)) SWIG_fail;
40555 {
40556 PyThreadState* __tstate = wxPyBeginAllowThreads();
40557 result = (PyObject *)wxGBPosition_Get(arg1);
40558
40559 wxPyEndAllowThreads(__tstate);
40560 if (PyErr_Occurred()) SWIG_fail;
40561 }
40562 resultobj = result;
40563 return resultobj;
40564 fail:
40565 return NULL;
40566 }
40567
40568
40569 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
40570 PyObject *obj;
40571 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40572 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
40573 Py_INCREF(obj);
40574 return Py_BuildValue((char *)"");
40575 }
40576 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
40577 PyObject *resultobj;
40578 int arg1 = (int) 1 ;
40579 int arg2 = (int) 1 ;
40580 wxGBSpan *result;
40581 PyObject * obj0 = 0 ;
40582 PyObject * obj1 = 0 ;
40583 char *kwnames[] = {
40584 (char *) "rowspan",(char *) "colspan", NULL
40585 };
40586
40587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
40588 if (obj0) {
40589 {
40590 arg1 = (int)(SWIG_As_int(obj0));
40591 if (SWIG_arg_fail(1)) SWIG_fail;
40592 }
40593 }
40594 if (obj1) {
40595 {
40596 arg2 = (int)(SWIG_As_int(obj1));
40597 if (SWIG_arg_fail(2)) SWIG_fail;
40598 }
40599 }
40600 {
40601 PyThreadState* __tstate = wxPyBeginAllowThreads();
40602 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
40603
40604 wxPyEndAllowThreads(__tstate);
40605 if (PyErr_Occurred()) SWIG_fail;
40606 }
40607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
40608 return resultobj;
40609 fail:
40610 return NULL;
40611 }
40612
40613
40614 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40615 PyObject *resultobj;
40616 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40617 int result;
40618 PyObject * obj0 = 0 ;
40619 char *kwnames[] = {
40620 (char *) "self", NULL
40621 };
40622
40623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
40624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40625 if (SWIG_arg_fail(1)) SWIG_fail;
40626 {
40627 PyThreadState* __tstate = wxPyBeginAllowThreads();
40628 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
40629
40630 wxPyEndAllowThreads(__tstate);
40631 if (PyErr_Occurred()) SWIG_fail;
40632 }
40633 {
40634 resultobj = SWIG_From_int((int)(result));
40635 }
40636 return resultobj;
40637 fail:
40638 return NULL;
40639 }
40640
40641
40642 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40643 PyObject *resultobj;
40644 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40645 int result;
40646 PyObject * obj0 = 0 ;
40647 char *kwnames[] = {
40648 (char *) "self", NULL
40649 };
40650
40651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
40652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40653 if (SWIG_arg_fail(1)) SWIG_fail;
40654 {
40655 PyThreadState* __tstate = wxPyBeginAllowThreads();
40656 result = (int)((wxGBSpan const *)arg1)->GetColspan();
40657
40658 wxPyEndAllowThreads(__tstate);
40659 if (PyErr_Occurred()) SWIG_fail;
40660 }
40661 {
40662 resultobj = SWIG_From_int((int)(result));
40663 }
40664 return resultobj;
40665 fail:
40666 return NULL;
40667 }
40668
40669
40670 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40671 PyObject *resultobj;
40672 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40673 int arg2 ;
40674 PyObject * obj0 = 0 ;
40675 PyObject * obj1 = 0 ;
40676 char *kwnames[] = {
40677 (char *) "self",(char *) "rowspan", NULL
40678 };
40679
40680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
40681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40682 if (SWIG_arg_fail(1)) SWIG_fail;
40683 {
40684 arg2 = (int)(SWIG_As_int(obj1));
40685 if (SWIG_arg_fail(2)) SWIG_fail;
40686 }
40687 {
40688 PyThreadState* __tstate = wxPyBeginAllowThreads();
40689 (arg1)->SetRowspan(arg2);
40690
40691 wxPyEndAllowThreads(__tstate);
40692 if (PyErr_Occurred()) SWIG_fail;
40693 }
40694 Py_INCREF(Py_None); resultobj = Py_None;
40695 return resultobj;
40696 fail:
40697 return NULL;
40698 }
40699
40700
40701 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40702 PyObject *resultobj;
40703 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40704 int arg2 ;
40705 PyObject * obj0 = 0 ;
40706 PyObject * obj1 = 0 ;
40707 char *kwnames[] = {
40708 (char *) "self",(char *) "colspan", NULL
40709 };
40710
40711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
40712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40713 if (SWIG_arg_fail(1)) SWIG_fail;
40714 {
40715 arg2 = (int)(SWIG_As_int(obj1));
40716 if (SWIG_arg_fail(2)) SWIG_fail;
40717 }
40718 {
40719 PyThreadState* __tstate = wxPyBeginAllowThreads();
40720 (arg1)->SetColspan(arg2);
40721
40722 wxPyEndAllowThreads(__tstate);
40723 if (PyErr_Occurred()) SWIG_fail;
40724 }
40725 Py_INCREF(Py_None); resultobj = Py_None;
40726 return resultobj;
40727 fail:
40728 return NULL;
40729 }
40730
40731
40732 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40733 PyObject *resultobj;
40734 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40735 wxGBSpan *arg2 = 0 ;
40736 bool result;
40737 wxGBSpan temp2 ;
40738 PyObject * obj0 = 0 ;
40739 PyObject * obj1 = 0 ;
40740 char *kwnames[] = {
40741 (char *) "self",(char *) "other", NULL
40742 };
40743
40744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
40745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40746 if (SWIG_arg_fail(1)) SWIG_fail;
40747 {
40748 arg2 = &temp2;
40749 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40750 }
40751 {
40752 PyThreadState* __tstate = wxPyBeginAllowThreads();
40753 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
40754
40755 wxPyEndAllowThreads(__tstate);
40756 if (PyErr_Occurred()) SWIG_fail;
40757 }
40758 {
40759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40760 }
40761 return resultobj;
40762 fail:
40763 return NULL;
40764 }
40765
40766
40767 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40768 PyObject *resultobj;
40769 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40770 wxGBSpan *arg2 = 0 ;
40771 bool result;
40772 wxGBSpan temp2 ;
40773 PyObject * obj0 = 0 ;
40774 PyObject * obj1 = 0 ;
40775 char *kwnames[] = {
40776 (char *) "self",(char *) "other", NULL
40777 };
40778
40779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
40780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40781 if (SWIG_arg_fail(1)) SWIG_fail;
40782 {
40783 arg2 = &temp2;
40784 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
40785 }
40786 {
40787 PyThreadState* __tstate = wxPyBeginAllowThreads();
40788 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
40789
40790 wxPyEndAllowThreads(__tstate);
40791 if (PyErr_Occurred()) SWIG_fail;
40792 }
40793 {
40794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40795 }
40796 return resultobj;
40797 fail:
40798 return NULL;
40799 }
40800
40801
40802 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40803 PyObject *resultobj;
40804 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40805 int arg2 = (int) 1 ;
40806 int arg3 = (int) 1 ;
40807 PyObject * obj0 = 0 ;
40808 PyObject * obj1 = 0 ;
40809 PyObject * obj2 = 0 ;
40810 char *kwnames[] = {
40811 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
40812 };
40813
40814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40816 if (SWIG_arg_fail(1)) SWIG_fail;
40817 if (obj1) {
40818 {
40819 arg2 = (int)(SWIG_As_int(obj1));
40820 if (SWIG_arg_fail(2)) SWIG_fail;
40821 }
40822 }
40823 if (obj2) {
40824 {
40825 arg3 = (int)(SWIG_As_int(obj2));
40826 if (SWIG_arg_fail(3)) SWIG_fail;
40827 }
40828 }
40829 {
40830 PyThreadState* __tstate = wxPyBeginAllowThreads();
40831 wxGBSpan_Set(arg1,arg2,arg3);
40832
40833 wxPyEndAllowThreads(__tstate);
40834 if (PyErr_Occurred()) SWIG_fail;
40835 }
40836 Py_INCREF(Py_None); resultobj = Py_None;
40837 return resultobj;
40838 fail:
40839 return NULL;
40840 }
40841
40842
40843 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40844 PyObject *resultobj;
40845 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40846 PyObject *result;
40847 PyObject * obj0 = 0 ;
40848 char *kwnames[] = {
40849 (char *) "self", NULL
40850 };
40851
40852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
40853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40854 if (SWIG_arg_fail(1)) SWIG_fail;
40855 {
40856 PyThreadState* __tstate = wxPyBeginAllowThreads();
40857 result = (PyObject *)wxGBSpan_Get(arg1);
40858
40859 wxPyEndAllowThreads(__tstate);
40860 if (PyErr_Occurred()) SWIG_fail;
40861 }
40862 resultobj = result;
40863 return resultobj;
40864 fail:
40865 return NULL;
40866 }
40867
40868
40869 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
40870 PyObject *obj;
40871 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40872 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
40873 Py_INCREF(obj);
40874 return Py_BuildValue((char *)"");
40875 }
40876 static int _wrap_DefaultSpan_set(PyObject *) {
40877 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
40878 return 1;
40879 }
40880
40881
40882 static PyObject *_wrap_DefaultSpan_get(void) {
40883 PyObject *pyobj;
40884
40885 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
40886 return pyobj;
40887 }
40888
40889
40890 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
40891 PyObject *resultobj;
40892 wxGBSizerItem *result;
40893 char *kwnames[] = {
40894 NULL
40895 };
40896
40897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
40898 {
40899 PyThreadState* __tstate = wxPyBeginAllowThreads();
40900 result = (wxGBSizerItem *)new wxGBSizerItem();
40901
40902 wxPyEndAllowThreads(__tstate);
40903 if (PyErr_Occurred()) SWIG_fail;
40904 }
40905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
40906 return resultobj;
40907 fail:
40908 return NULL;
40909 }
40910
40911
40912 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40913 PyObject *resultobj;
40914 wxWindow *arg1 = (wxWindow *) 0 ;
40915 wxGBPosition *arg2 = 0 ;
40916 wxGBSpan *arg3 = 0 ;
40917 int arg4 ;
40918 int arg5 ;
40919 PyObject *arg6 = (PyObject *) NULL ;
40920 wxGBSizerItem *result;
40921 wxGBPosition temp2 ;
40922 wxGBSpan temp3 ;
40923 PyObject * obj0 = 0 ;
40924 PyObject * obj1 = 0 ;
40925 PyObject * obj2 = 0 ;
40926 PyObject * obj3 = 0 ;
40927 PyObject * obj4 = 0 ;
40928 PyObject * obj5 = 0 ;
40929 char *kwnames[] = {
40930 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
40931 };
40932
40933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40935 if (SWIG_arg_fail(1)) SWIG_fail;
40936 {
40937 arg2 = &temp2;
40938 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40939 }
40940 {
40941 arg3 = &temp3;
40942 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
40943 }
40944 {
40945 arg4 = (int)(SWIG_As_int(obj3));
40946 if (SWIG_arg_fail(4)) SWIG_fail;
40947 }
40948 {
40949 arg5 = (int)(SWIG_As_int(obj4));
40950 if (SWIG_arg_fail(5)) SWIG_fail;
40951 }
40952 if (obj5) {
40953 arg6 = obj5;
40954 }
40955 {
40956 PyThreadState* __tstate = wxPyBeginAllowThreads();
40957 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
40958
40959 wxPyEndAllowThreads(__tstate);
40960 if (PyErr_Occurred()) SWIG_fail;
40961 }
40962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
40963 return resultobj;
40964 fail:
40965 return NULL;
40966 }
40967
40968
40969 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40970 PyObject *resultobj;
40971 wxSizer *arg1 = (wxSizer *) 0 ;
40972 wxGBPosition *arg2 = 0 ;
40973 wxGBSpan *arg3 = 0 ;
40974 int arg4 ;
40975 int arg5 ;
40976 PyObject *arg6 = (PyObject *) NULL ;
40977 wxGBSizerItem *result;
40978 wxGBPosition temp2 ;
40979 wxGBSpan temp3 ;
40980 PyObject * obj0 = 0 ;
40981 PyObject * obj1 = 0 ;
40982 PyObject * obj2 = 0 ;
40983 PyObject * obj3 = 0 ;
40984 PyObject * obj4 = 0 ;
40985 PyObject * obj5 = 0 ;
40986 char *kwnames[] = {
40987 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
40988 };
40989
40990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40992 if (SWIG_arg_fail(1)) SWIG_fail;
40993 {
40994 arg2 = &temp2;
40995 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40996 }
40997 {
40998 arg3 = &temp3;
40999 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41000 }
41001 {
41002 arg4 = (int)(SWIG_As_int(obj3));
41003 if (SWIG_arg_fail(4)) SWIG_fail;
41004 }
41005 {
41006 arg5 = (int)(SWIG_As_int(obj4));
41007 if (SWIG_arg_fail(5)) SWIG_fail;
41008 }
41009 if (obj5) {
41010 arg6 = obj5;
41011 }
41012 {
41013 PyThreadState* __tstate = wxPyBeginAllowThreads();
41014 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41015
41016 wxPyEndAllowThreads(__tstate);
41017 if (PyErr_Occurred()) SWIG_fail;
41018 }
41019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41020 return resultobj;
41021 fail:
41022 return NULL;
41023 }
41024
41025
41026 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41027 PyObject *resultobj;
41028 int arg1 ;
41029 int arg2 ;
41030 wxGBPosition *arg3 = 0 ;
41031 wxGBSpan *arg4 = 0 ;
41032 int arg5 ;
41033 int arg6 ;
41034 PyObject *arg7 = (PyObject *) NULL ;
41035 wxGBSizerItem *result;
41036 wxGBPosition temp3 ;
41037 wxGBSpan temp4 ;
41038 PyObject * obj0 = 0 ;
41039 PyObject * obj1 = 0 ;
41040 PyObject * obj2 = 0 ;
41041 PyObject * obj3 = 0 ;
41042 PyObject * obj4 = 0 ;
41043 PyObject * obj5 = 0 ;
41044 PyObject * obj6 = 0 ;
41045 char *kwnames[] = {
41046 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41047 };
41048
41049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41050 {
41051 arg1 = (int)(SWIG_As_int(obj0));
41052 if (SWIG_arg_fail(1)) SWIG_fail;
41053 }
41054 {
41055 arg2 = (int)(SWIG_As_int(obj1));
41056 if (SWIG_arg_fail(2)) SWIG_fail;
41057 }
41058 {
41059 arg3 = &temp3;
41060 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41061 }
41062 {
41063 arg4 = &temp4;
41064 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41065 }
41066 {
41067 arg5 = (int)(SWIG_As_int(obj4));
41068 if (SWIG_arg_fail(5)) SWIG_fail;
41069 }
41070 {
41071 arg6 = (int)(SWIG_As_int(obj5));
41072 if (SWIG_arg_fail(6)) SWIG_fail;
41073 }
41074 if (obj6) {
41075 arg7 = obj6;
41076 }
41077 {
41078 PyThreadState* __tstate = wxPyBeginAllowThreads();
41079 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41080
41081 wxPyEndAllowThreads(__tstate);
41082 if (PyErr_Occurred()) SWIG_fail;
41083 }
41084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41085 return resultobj;
41086 fail:
41087 return NULL;
41088 }
41089
41090
41091 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41092 PyObject *resultobj;
41093 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41094 wxGBPosition result;
41095 PyObject * obj0 = 0 ;
41096 char *kwnames[] = {
41097 (char *) "self", NULL
41098 };
41099
41100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
41101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41102 if (SWIG_arg_fail(1)) SWIG_fail;
41103 {
41104 PyThreadState* __tstate = wxPyBeginAllowThreads();
41105 result = ((wxGBSizerItem const *)arg1)->GetPos();
41106
41107 wxPyEndAllowThreads(__tstate);
41108 if (PyErr_Occurred()) SWIG_fail;
41109 }
41110 {
41111 wxGBPosition * resultptr;
41112 resultptr = new wxGBPosition((wxGBPosition &)(result));
41113 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41114 }
41115 return resultobj;
41116 fail:
41117 return NULL;
41118 }
41119
41120
41121 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41122 PyObject *resultobj;
41123 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41124 wxGBSpan result;
41125 PyObject * obj0 = 0 ;
41126 char *kwnames[] = {
41127 (char *) "self", NULL
41128 };
41129
41130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
41131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41132 if (SWIG_arg_fail(1)) SWIG_fail;
41133 {
41134 PyThreadState* __tstate = wxPyBeginAllowThreads();
41135 result = ((wxGBSizerItem const *)arg1)->GetSpan();
41136
41137 wxPyEndAllowThreads(__tstate);
41138 if (PyErr_Occurred()) SWIG_fail;
41139 }
41140 {
41141 wxGBSpan * resultptr;
41142 resultptr = new wxGBSpan((wxGBSpan &)(result));
41143 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41144 }
41145 return resultobj;
41146 fail:
41147 return NULL;
41148 }
41149
41150
41151 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41152 PyObject *resultobj;
41153 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41154 wxGBPosition *arg2 = 0 ;
41155 bool result;
41156 wxGBPosition temp2 ;
41157 PyObject * obj0 = 0 ;
41158 PyObject * obj1 = 0 ;
41159 char *kwnames[] = {
41160 (char *) "self",(char *) "pos", NULL
41161 };
41162
41163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
41164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41165 if (SWIG_arg_fail(1)) SWIG_fail;
41166 {
41167 arg2 = &temp2;
41168 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41169 }
41170 {
41171 PyThreadState* __tstate = wxPyBeginAllowThreads();
41172 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
41173
41174 wxPyEndAllowThreads(__tstate);
41175 if (PyErr_Occurred()) SWIG_fail;
41176 }
41177 {
41178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41179 }
41180 return resultobj;
41181 fail:
41182 return NULL;
41183 }
41184
41185
41186 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41187 PyObject *resultobj;
41188 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41189 wxGBSpan *arg2 = 0 ;
41190 bool result;
41191 wxGBSpan temp2 ;
41192 PyObject * obj0 = 0 ;
41193 PyObject * obj1 = 0 ;
41194 char *kwnames[] = {
41195 (char *) "self",(char *) "span", NULL
41196 };
41197
41198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
41199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41200 if (SWIG_arg_fail(1)) SWIG_fail;
41201 {
41202 arg2 = &temp2;
41203 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41204 }
41205 {
41206 PyThreadState* __tstate = wxPyBeginAllowThreads();
41207 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
41208
41209 wxPyEndAllowThreads(__tstate);
41210 if (PyErr_Occurred()) SWIG_fail;
41211 }
41212 {
41213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41214 }
41215 return resultobj;
41216 fail:
41217 return NULL;
41218 }
41219
41220
41221 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
41222 PyObject *resultobj;
41223 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41224 wxGBSizerItem *arg2 = 0 ;
41225 bool result;
41226 PyObject * obj0 = 0 ;
41227 PyObject * obj1 = 0 ;
41228 char *kwnames[] = {
41229 (char *) "self",(char *) "other", NULL
41230 };
41231
41232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
41233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41234 if (SWIG_arg_fail(1)) SWIG_fail;
41235 {
41236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41237 if (SWIG_arg_fail(2)) SWIG_fail;
41238 if (arg2 == NULL) {
41239 SWIG_null_ref("wxGBSizerItem");
41240 }
41241 if (SWIG_arg_fail(2)) SWIG_fail;
41242 }
41243 {
41244 PyThreadState* __tstate = wxPyBeginAllowThreads();
41245 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
41246
41247 wxPyEndAllowThreads(__tstate);
41248 if (PyErr_Occurred()) SWIG_fail;
41249 }
41250 {
41251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41252 }
41253 return resultobj;
41254 fail:
41255 return NULL;
41256 }
41257
41258
41259 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
41260 PyObject *resultobj;
41261 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41262 wxGBPosition *arg2 = 0 ;
41263 wxGBSpan *arg3 = 0 ;
41264 bool result;
41265 wxGBPosition temp2 ;
41266 wxGBSpan temp3 ;
41267 PyObject * obj0 = 0 ;
41268 PyObject * obj1 = 0 ;
41269 PyObject * obj2 = 0 ;
41270 char *kwnames[] = {
41271 (char *) "self",(char *) "pos",(char *) "span", NULL
41272 };
41273
41274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
41275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41276 if (SWIG_arg_fail(1)) SWIG_fail;
41277 {
41278 arg2 = &temp2;
41279 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41280 }
41281 {
41282 arg3 = &temp3;
41283 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41284 }
41285 {
41286 PyThreadState* __tstate = wxPyBeginAllowThreads();
41287 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
41288
41289 wxPyEndAllowThreads(__tstate);
41290 if (PyErr_Occurred()) SWIG_fail;
41291 }
41292 {
41293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41294 }
41295 return resultobj;
41296 fail:
41297 return NULL;
41298 }
41299
41300
41301 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
41302 PyObject *resultobj;
41303 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41304 wxGBPosition result;
41305 PyObject * obj0 = 0 ;
41306 char *kwnames[] = {
41307 (char *) "self", NULL
41308 };
41309
41310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
41311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41312 if (SWIG_arg_fail(1)) SWIG_fail;
41313 {
41314 PyThreadState* __tstate = wxPyBeginAllowThreads();
41315 result = wxGBSizerItem_GetEndPos(arg1);
41316
41317 wxPyEndAllowThreads(__tstate);
41318 if (PyErr_Occurred()) SWIG_fail;
41319 }
41320 {
41321 wxGBPosition * resultptr;
41322 resultptr = new wxGBPosition((wxGBPosition &)(result));
41323 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41324 }
41325 return resultobj;
41326 fail:
41327 return NULL;
41328 }
41329
41330
41331 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41332 PyObject *resultobj;
41333 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41334 wxGridBagSizer *result;
41335 PyObject * obj0 = 0 ;
41336 char *kwnames[] = {
41337 (char *) "self", NULL
41338 };
41339
41340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
41341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41342 if (SWIG_arg_fail(1)) SWIG_fail;
41343 {
41344 PyThreadState* __tstate = wxPyBeginAllowThreads();
41345 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
41346
41347 wxPyEndAllowThreads(__tstate);
41348 if (PyErr_Occurred()) SWIG_fail;
41349 }
41350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
41351 return resultobj;
41352 fail:
41353 return NULL;
41354 }
41355
41356
41357 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41358 PyObject *resultobj;
41359 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41360 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
41361 PyObject * obj0 = 0 ;
41362 PyObject * obj1 = 0 ;
41363 char *kwnames[] = {
41364 (char *) "self",(char *) "sizer", NULL
41365 };
41366
41367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
41368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41369 if (SWIG_arg_fail(1)) SWIG_fail;
41370 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41371 if (SWIG_arg_fail(2)) SWIG_fail;
41372 {
41373 PyThreadState* __tstate = wxPyBeginAllowThreads();
41374 (arg1)->SetGBSizer(arg2);
41375
41376 wxPyEndAllowThreads(__tstate);
41377 if (PyErr_Occurred()) SWIG_fail;
41378 }
41379 Py_INCREF(Py_None); resultobj = Py_None;
41380 return resultobj;
41381 fail:
41382 return NULL;
41383 }
41384
41385
41386 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
41387 PyObject *obj;
41388 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41389 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
41390 Py_INCREF(obj);
41391 return Py_BuildValue((char *)"");
41392 }
41393 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41394 PyObject *resultobj;
41395 int arg1 = (int) 0 ;
41396 int arg2 = (int) 0 ;
41397 wxGridBagSizer *result;
41398 PyObject * obj0 = 0 ;
41399 PyObject * obj1 = 0 ;
41400 char *kwnames[] = {
41401 (char *) "vgap",(char *) "hgap", NULL
41402 };
41403
41404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
41405 if (obj0) {
41406 {
41407 arg1 = (int)(SWIG_As_int(obj0));
41408 if (SWIG_arg_fail(1)) SWIG_fail;
41409 }
41410 }
41411 if (obj1) {
41412 {
41413 arg2 = (int)(SWIG_As_int(obj1));
41414 if (SWIG_arg_fail(2)) SWIG_fail;
41415 }
41416 }
41417 {
41418 PyThreadState* __tstate = wxPyBeginAllowThreads();
41419 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
41420
41421 wxPyEndAllowThreads(__tstate);
41422 if (PyErr_Occurred()) SWIG_fail;
41423 }
41424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
41425 return resultobj;
41426 fail:
41427 return NULL;
41428 }
41429
41430
41431 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
41432 PyObject *resultobj;
41433 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41434 PyObject *arg2 = (PyObject *) 0 ;
41435 wxGBPosition *arg3 = 0 ;
41436 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
41437 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
41438 int arg5 = (int) 0 ;
41439 int arg6 = (int) 0 ;
41440 PyObject *arg7 = (PyObject *) NULL ;
41441 wxGBSizerItem *result;
41442 wxGBPosition temp3 ;
41443 wxGBSpan temp4 ;
41444 PyObject * obj0 = 0 ;
41445 PyObject * obj1 = 0 ;
41446 PyObject * obj2 = 0 ;
41447 PyObject * obj3 = 0 ;
41448 PyObject * obj4 = 0 ;
41449 PyObject * obj5 = 0 ;
41450 PyObject * obj6 = 0 ;
41451 char *kwnames[] = {
41452 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41453 };
41454
41455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41457 if (SWIG_arg_fail(1)) SWIG_fail;
41458 arg2 = obj1;
41459 {
41460 arg3 = &temp3;
41461 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41462 }
41463 if (obj3) {
41464 {
41465 arg4 = &temp4;
41466 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41467 }
41468 }
41469 if (obj4) {
41470 {
41471 arg5 = (int)(SWIG_As_int(obj4));
41472 if (SWIG_arg_fail(5)) SWIG_fail;
41473 }
41474 }
41475 if (obj5) {
41476 {
41477 arg6 = (int)(SWIG_As_int(obj5));
41478 if (SWIG_arg_fail(6)) SWIG_fail;
41479 }
41480 }
41481 if (obj6) {
41482 arg7 = obj6;
41483 }
41484 {
41485 PyThreadState* __tstate = wxPyBeginAllowThreads();
41486 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41487
41488 wxPyEndAllowThreads(__tstate);
41489 if (PyErr_Occurred()) SWIG_fail;
41490 }
41491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41492 return resultobj;
41493 fail:
41494 return NULL;
41495 }
41496
41497
41498 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
41499 PyObject *resultobj;
41500 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41501 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
41502 wxGBSizerItem *result;
41503 PyObject * obj0 = 0 ;
41504 PyObject * obj1 = 0 ;
41505 char *kwnames[] = {
41506 (char *) "self",(char *) "item", NULL
41507 };
41508
41509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
41510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41511 if (SWIG_arg_fail(1)) SWIG_fail;
41512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41513 if (SWIG_arg_fail(2)) SWIG_fail;
41514 {
41515 PyThreadState* __tstate = wxPyBeginAllowThreads();
41516 result = (wxGBSizerItem *)(arg1)->Add(arg2);
41517
41518 wxPyEndAllowThreads(__tstate);
41519 if (PyErr_Occurred()) SWIG_fail;
41520 }
41521 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41522 return resultobj;
41523 fail:
41524 return NULL;
41525 }
41526
41527
41528 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41529 PyObject *resultobj;
41530 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41531 int arg2 ;
41532 int arg3 ;
41533 wxSize result;
41534 PyObject * obj0 = 0 ;
41535 PyObject * obj1 = 0 ;
41536 PyObject * obj2 = 0 ;
41537 char *kwnames[] = {
41538 (char *) "self",(char *) "row",(char *) "col", NULL
41539 };
41540
41541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
41542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41543 if (SWIG_arg_fail(1)) SWIG_fail;
41544 {
41545 arg2 = (int)(SWIG_As_int(obj1));
41546 if (SWIG_arg_fail(2)) SWIG_fail;
41547 }
41548 {
41549 arg3 = (int)(SWIG_As_int(obj2));
41550 if (SWIG_arg_fail(3)) SWIG_fail;
41551 }
41552 {
41553 PyThreadState* __tstate = wxPyBeginAllowThreads();
41554 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
41555
41556 wxPyEndAllowThreads(__tstate);
41557 if (PyErr_Occurred()) SWIG_fail;
41558 }
41559 {
41560 wxSize * resultptr;
41561 resultptr = new wxSize((wxSize &)(result));
41562 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41563 }
41564 return resultobj;
41565 fail:
41566 return NULL;
41567 }
41568
41569
41570 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41571 PyObject *resultobj;
41572 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41573 wxSize result;
41574 PyObject * obj0 = 0 ;
41575 char *kwnames[] = {
41576 (char *) "self", NULL
41577 };
41578
41579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
41580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41581 if (SWIG_arg_fail(1)) SWIG_fail;
41582 {
41583 PyThreadState* __tstate = wxPyBeginAllowThreads();
41584 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
41585
41586 wxPyEndAllowThreads(__tstate);
41587 if (PyErr_Occurred()) SWIG_fail;
41588 }
41589 {
41590 wxSize * resultptr;
41591 resultptr = new wxSize((wxSize &)(result));
41592 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41593 }
41594 return resultobj;
41595 fail:
41596 return NULL;
41597 }
41598
41599
41600 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41601 PyObject *resultobj;
41602 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41603 wxSize *arg2 = 0 ;
41604 wxSize temp2 ;
41605 PyObject * obj0 = 0 ;
41606 PyObject * obj1 = 0 ;
41607 char *kwnames[] = {
41608 (char *) "self",(char *) "sz", NULL
41609 };
41610
41611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
41612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41613 if (SWIG_arg_fail(1)) SWIG_fail;
41614 {
41615 arg2 = &temp2;
41616 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
41617 }
41618 {
41619 PyThreadState* __tstate = wxPyBeginAllowThreads();
41620 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
41621
41622 wxPyEndAllowThreads(__tstate);
41623 if (PyErr_Occurred()) SWIG_fail;
41624 }
41625 Py_INCREF(Py_None); resultobj = Py_None;
41626 return resultobj;
41627 fail:
41628 return NULL;
41629 }
41630
41631
41632 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41633 PyObject *resultobj;
41634 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41635 wxWindow *arg2 = (wxWindow *) 0 ;
41636 wxGBPosition result;
41637 PyObject * obj0 = 0 ;
41638 PyObject * obj1 = 0 ;
41639
41640 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41642 if (SWIG_arg_fail(1)) SWIG_fail;
41643 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41644 if (SWIG_arg_fail(2)) SWIG_fail;
41645 {
41646 PyThreadState* __tstate = wxPyBeginAllowThreads();
41647 result = (arg1)->GetItemPosition(arg2);
41648
41649 wxPyEndAllowThreads(__tstate);
41650 if (PyErr_Occurred()) SWIG_fail;
41651 }
41652 {
41653 wxGBPosition * resultptr;
41654 resultptr = new wxGBPosition((wxGBPosition &)(result));
41655 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41656 }
41657 return resultobj;
41658 fail:
41659 return NULL;
41660 }
41661
41662
41663 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
41664 PyObject *resultobj;
41665 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41666 wxSizer *arg2 = (wxSizer *) 0 ;
41667 wxGBPosition result;
41668 PyObject * obj0 = 0 ;
41669 PyObject * obj1 = 0 ;
41670
41671 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41673 if (SWIG_arg_fail(1)) SWIG_fail;
41674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41675 if (SWIG_arg_fail(2)) SWIG_fail;
41676 {
41677 PyThreadState* __tstate = wxPyBeginAllowThreads();
41678 result = (arg1)->GetItemPosition(arg2);
41679
41680 wxPyEndAllowThreads(__tstate);
41681 if (PyErr_Occurred()) SWIG_fail;
41682 }
41683 {
41684 wxGBPosition * resultptr;
41685 resultptr = new wxGBPosition((wxGBPosition &)(result));
41686 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41687 }
41688 return resultobj;
41689 fail:
41690 return NULL;
41691 }
41692
41693
41694 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
41695 PyObject *resultobj;
41696 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41697 size_t arg2 ;
41698 wxGBPosition result;
41699 PyObject * obj0 = 0 ;
41700 PyObject * obj1 = 0 ;
41701
41702 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41704 if (SWIG_arg_fail(1)) SWIG_fail;
41705 {
41706 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41707 if (SWIG_arg_fail(2)) SWIG_fail;
41708 }
41709 {
41710 PyThreadState* __tstate = wxPyBeginAllowThreads();
41711 result = (arg1)->GetItemPosition(arg2);
41712
41713 wxPyEndAllowThreads(__tstate);
41714 if (PyErr_Occurred()) SWIG_fail;
41715 }
41716 {
41717 wxGBPosition * resultptr;
41718 resultptr = new wxGBPosition((wxGBPosition &)(result));
41719 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41720 }
41721 return resultobj;
41722 fail:
41723 return NULL;
41724 }
41725
41726
41727 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
41728 int argc;
41729 PyObject *argv[3];
41730 int ii;
41731
41732 argc = PyObject_Length(args);
41733 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
41734 argv[ii] = PyTuple_GetItem(args,ii);
41735 }
41736 if (argc == 2) {
41737 int _v;
41738 {
41739 void *ptr;
41740 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41741 _v = 0;
41742 PyErr_Clear();
41743 } else {
41744 _v = 1;
41745 }
41746 }
41747 if (_v) {
41748 {
41749 void *ptr;
41750 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
41751 _v = 0;
41752 PyErr_Clear();
41753 } else {
41754 _v = 1;
41755 }
41756 }
41757 if (_v) {
41758 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
41759 }
41760 }
41761 }
41762 if (argc == 2) {
41763 int _v;
41764 {
41765 void *ptr;
41766 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41767 _v = 0;
41768 PyErr_Clear();
41769 } else {
41770 _v = 1;
41771 }
41772 }
41773 if (_v) {
41774 {
41775 void *ptr;
41776 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
41777 _v = 0;
41778 PyErr_Clear();
41779 } else {
41780 _v = 1;
41781 }
41782 }
41783 if (_v) {
41784 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
41785 }
41786 }
41787 }
41788 if (argc == 2) {
41789 int _v;
41790 {
41791 void *ptr;
41792 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41793 _v = 0;
41794 PyErr_Clear();
41795 } else {
41796 _v = 1;
41797 }
41798 }
41799 if (_v) {
41800 _v = SWIG_Check_unsigned_SS_long(argv[1]);
41801 if (_v) {
41802 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
41803 }
41804 }
41805 }
41806
41807 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
41808 return NULL;
41809 }
41810
41811
41812 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41813 PyObject *resultobj;
41814 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41815 wxWindow *arg2 = (wxWindow *) 0 ;
41816 wxGBPosition *arg3 = 0 ;
41817 bool result;
41818 wxGBPosition temp3 ;
41819 PyObject * obj0 = 0 ;
41820 PyObject * obj1 = 0 ;
41821 PyObject * obj2 = 0 ;
41822
41823 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41825 if (SWIG_arg_fail(1)) SWIG_fail;
41826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41827 if (SWIG_arg_fail(2)) SWIG_fail;
41828 {
41829 arg3 = &temp3;
41830 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41831 }
41832 {
41833 PyThreadState* __tstate = wxPyBeginAllowThreads();
41834 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41835
41836 wxPyEndAllowThreads(__tstate);
41837 if (PyErr_Occurred()) SWIG_fail;
41838 }
41839 {
41840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41841 }
41842 return resultobj;
41843 fail:
41844 return NULL;
41845 }
41846
41847
41848 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
41849 PyObject *resultobj;
41850 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41851 wxSizer *arg2 = (wxSizer *) 0 ;
41852 wxGBPosition *arg3 = 0 ;
41853 bool result;
41854 wxGBPosition temp3 ;
41855 PyObject * obj0 = 0 ;
41856 PyObject * obj1 = 0 ;
41857 PyObject * obj2 = 0 ;
41858
41859 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41861 if (SWIG_arg_fail(1)) SWIG_fail;
41862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41863 if (SWIG_arg_fail(2)) SWIG_fail;
41864 {
41865 arg3 = &temp3;
41866 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41867 }
41868 {
41869 PyThreadState* __tstate = wxPyBeginAllowThreads();
41870 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41871
41872 wxPyEndAllowThreads(__tstate);
41873 if (PyErr_Occurred()) SWIG_fail;
41874 }
41875 {
41876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41877 }
41878 return resultobj;
41879 fail:
41880 return NULL;
41881 }
41882
41883
41884 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
41885 PyObject *resultobj;
41886 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41887 size_t arg2 ;
41888 wxGBPosition *arg3 = 0 ;
41889 bool result;
41890 wxGBPosition temp3 ;
41891 PyObject * obj0 = 0 ;
41892 PyObject * obj1 = 0 ;
41893 PyObject * obj2 = 0 ;
41894
41895 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
41896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41897 if (SWIG_arg_fail(1)) SWIG_fail;
41898 {
41899 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41900 if (SWIG_arg_fail(2)) SWIG_fail;
41901 }
41902 {
41903 arg3 = &temp3;
41904 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41905 }
41906 {
41907 PyThreadState* __tstate = wxPyBeginAllowThreads();
41908 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
41909
41910 wxPyEndAllowThreads(__tstate);
41911 if (PyErr_Occurred()) SWIG_fail;
41912 }
41913 {
41914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41915 }
41916 return resultobj;
41917 fail:
41918 return NULL;
41919 }
41920
41921
41922 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
41923 int argc;
41924 PyObject *argv[4];
41925 int ii;
41926
41927 argc = PyObject_Length(args);
41928 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
41929 argv[ii] = PyTuple_GetItem(args,ii);
41930 }
41931 if (argc == 3) {
41932 int _v;
41933 {
41934 void *ptr;
41935 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41936 _v = 0;
41937 PyErr_Clear();
41938 } else {
41939 _v = 1;
41940 }
41941 }
41942 if (_v) {
41943 {
41944 void *ptr;
41945 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
41946 _v = 0;
41947 PyErr_Clear();
41948 } else {
41949 _v = 1;
41950 }
41951 }
41952 if (_v) {
41953 {
41954 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
41955 }
41956 if (_v) {
41957 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
41958 }
41959 }
41960 }
41961 }
41962 if (argc == 3) {
41963 int _v;
41964 {
41965 void *ptr;
41966 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41967 _v = 0;
41968 PyErr_Clear();
41969 } else {
41970 _v = 1;
41971 }
41972 }
41973 if (_v) {
41974 {
41975 void *ptr;
41976 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
41977 _v = 0;
41978 PyErr_Clear();
41979 } else {
41980 _v = 1;
41981 }
41982 }
41983 if (_v) {
41984 {
41985 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
41986 }
41987 if (_v) {
41988 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
41989 }
41990 }
41991 }
41992 }
41993 if (argc == 3) {
41994 int _v;
41995 {
41996 void *ptr;
41997 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
41998 _v = 0;
41999 PyErr_Clear();
42000 } else {
42001 _v = 1;
42002 }
42003 }
42004 if (_v) {
42005 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42006 if (_v) {
42007 {
42008 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42009 }
42010 if (_v) {
42011 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42012 }
42013 }
42014 }
42015 }
42016
42017 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42018 return NULL;
42019 }
42020
42021
42022 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42023 PyObject *resultobj;
42024 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42025 wxWindow *arg2 = (wxWindow *) 0 ;
42026 wxGBSpan result;
42027 PyObject * obj0 = 0 ;
42028 PyObject * obj1 = 0 ;
42029
42030 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42032 if (SWIG_arg_fail(1)) SWIG_fail;
42033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42034 if (SWIG_arg_fail(2)) SWIG_fail;
42035 {
42036 PyThreadState* __tstate = wxPyBeginAllowThreads();
42037 result = (arg1)->GetItemSpan(arg2);
42038
42039 wxPyEndAllowThreads(__tstate);
42040 if (PyErr_Occurred()) SWIG_fail;
42041 }
42042 {
42043 wxGBSpan * resultptr;
42044 resultptr = new wxGBSpan((wxGBSpan &)(result));
42045 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42046 }
42047 return resultobj;
42048 fail:
42049 return NULL;
42050 }
42051
42052
42053 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42054 PyObject *resultobj;
42055 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42056 wxSizer *arg2 = (wxSizer *) 0 ;
42057 wxGBSpan result;
42058 PyObject * obj0 = 0 ;
42059 PyObject * obj1 = 0 ;
42060
42061 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42063 if (SWIG_arg_fail(1)) SWIG_fail;
42064 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42065 if (SWIG_arg_fail(2)) SWIG_fail;
42066 {
42067 PyThreadState* __tstate = wxPyBeginAllowThreads();
42068 result = (arg1)->GetItemSpan(arg2);
42069
42070 wxPyEndAllowThreads(__tstate);
42071 if (PyErr_Occurred()) SWIG_fail;
42072 }
42073 {
42074 wxGBSpan * resultptr;
42075 resultptr = new wxGBSpan((wxGBSpan &)(result));
42076 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42077 }
42078 return resultobj;
42079 fail:
42080 return NULL;
42081 }
42082
42083
42084 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42085 PyObject *resultobj;
42086 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42087 size_t arg2 ;
42088 wxGBSpan result;
42089 PyObject * obj0 = 0 ;
42090 PyObject * obj1 = 0 ;
42091
42092 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42094 if (SWIG_arg_fail(1)) SWIG_fail;
42095 {
42096 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42097 if (SWIG_arg_fail(2)) SWIG_fail;
42098 }
42099 {
42100 PyThreadState* __tstate = wxPyBeginAllowThreads();
42101 result = (arg1)->GetItemSpan(arg2);
42102
42103 wxPyEndAllowThreads(__tstate);
42104 if (PyErr_Occurred()) SWIG_fail;
42105 }
42106 {
42107 wxGBSpan * resultptr;
42108 resultptr = new wxGBSpan((wxGBSpan &)(result));
42109 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42110 }
42111 return resultobj;
42112 fail:
42113 return NULL;
42114 }
42115
42116
42117 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
42118 int argc;
42119 PyObject *argv[3];
42120 int ii;
42121
42122 argc = PyObject_Length(args);
42123 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42124 argv[ii] = PyTuple_GetItem(args,ii);
42125 }
42126 if (argc == 2) {
42127 int _v;
42128 {
42129 void *ptr;
42130 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42131 _v = 0;
42132 PyErr_Clear();
42133 } else {
42134 _v = 1;
42135 }
42136 }
42137 if (_v) {
42138 {
42139 void *ptr;
42140 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42141 _v = 0;
42142 PyErr_Clear();
42143 } else {
42144 _v = 1;
42145 }
42146 }
42147 if (_v) {
42148 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
42149 }
42150 }
42151 }
42152 if (argc == 2) {
42153 int _v;
42154 {
42155 void *ptr;
42156 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42157 _v = 0;
42158 PyErr_Clear();
42159 } else {
42160 _v = 1;
42161 }
42162 }
42163 if (_v) {
42164 {
42165 void *ptr;
42166 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42167 _v = 0;
42168 PyErr_Clear();
42169 } else {
42170 _v = 1;
42171 }
42172 }
42173 if (_v) {
42174 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
42175 }
42176 }
42177 }
42178 if (argc == 2) {
42179 int _v;
42180 {
42181 void *ptr;
42182 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42183 _v = 0;
42184 PyErr_Clear();
42185 } else {
42186 _v = 1;
42187 }
42188 }
42189 if (_v) {
42190 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42191 if (_v) {
42192 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
42193 }
42194 }
42195 }
42196
42197 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
42198 return NULL;
42199 }
42200
42201
42202 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42203 PyObject *resultobj;
42204 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42205 wxWindow *arg2 = (wxWindow *) 0 ;
42206 wxGBSpan *arg3 = 0 ;
42207 bool result;
42208 wxGBSpan temp3 ;
42209 PyObject * obj0 = 0 ;
42210 PyObject * obj1 = 0 ;
42211 PyObject * obj2 = 0 ;
42212
42213 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42215 if (SWIG_arg_fail(1)) SWIG_fail;
42216 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42217 if (SWIG_arg_fail(2)) SWIG_fail;
42218 {
42219 arg3 = &temp3;
42220 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42221 }
42222 {
42223 PyThreadState* __tstate = wxPyBeginAllowThreads();
42224 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42225
42226 wxPyEndAllowThreads(__tstate);
42227 if (PyErr_Occurred()) SWIG_fail;
42228 }
42229 {
42230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42231 }
42232 return resultobj;
42233 fail:
42234 return NULL;
42235 }
42236
42237
42238 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42239 PyObject *resultobj;
42240 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42241 wxSizer *arg2 = (wxSizer *) 0 ;
42242 wxGBSpan *arg3 = 0 ;
42243 bool result;
42244 wxGBSpan temp3 ;
42245 PyObject * obj0 = 0 ;
42246 PyObject * obj1 = 0 ;
42247 PyObject * obj2 = 0 ;
42248
42249 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42251 if (SWIG_arg_fail(1)) SWIG_fail;
42252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42253 if (SWIG_arg_fail(2)) SWIG_fail;
42254 {
42255 arg3 = &temp3;
42256 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42257 }
42258 {
42259 PyThreadState* __tstate = wxPyBeginAllowThreads();
42260 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42261
42262 wxPyEndAllowThreads(__tstate);
42263 if (PyErr_Occurred()) SWIG_fail;
42264 }
42265 {
42266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42267 }
42268 return resultobj;
42269 fail:
42270 return NULL;
42271 }
42272
42273
42274 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42275 PyObject *resultobj;
42276 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42277 size_t arg2 ;
42278 wxGBSpan *arg3 = 0 ;
42279 bool result;
42280 wxGBSpan temp3 ;
42281 PyObject * obj0 = 0 ;
42282 PyObject * obj1 = 0 ;
42283 PyObject * obj2 = 0 ;
42284
42285 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42287 if (SWIG_arg_fail(1)) SWIG_fail;
42288 {
42289 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42290 if (SWIG_arg_fail(2)) SWIG_fail;
42291 }
42292 {
42293 arg3 = &temp3;
42294 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42295 }
42296 {
42297 PyThreadState* __tstate = wxPyBeginAllowThreads();
42298 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42299
42300 wxPyEndAllowThreads(__tstate);
42301 if (PyErr_Occurred()) SWIG_fail;
42302 }
42303 {
42304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42305 }
42306 return resultobj;
42307 fail:
42308 return NULL;
42309 }
42310
42311
42312 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
42313 int argc;
42314 PyObject *argv[4];
42315 int ii;
42316
42317 argc = PyObject_Length(args);
42318 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42319 argv[ii] = PyTuple_GetItem(args,ii);
42320 }
42321 if (argc == 3) {
42322 int _v;
42323 {
42324 void *ptr;
42325 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42326 _v = 0;
42327 PyErr_Clear();
42328 } else {
42329 _v = 1;
42330 }
42331 }
42332 if (_v) {
42333 {
42334 void *ptr;
42335 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42336 _v = 0;
42337 PyErr_Clear();
42338 } else {
42339 _v = 1;
42340 }
42341 }
42342 if (_v) {
42343 {
42344 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42345 }
42346 if (_v) {
42347 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
42348 }
42349 }
42350 }
42351 }
42352 if (argc == 3) {
42353 int _v;
42354 {
42355 void *ptr;
42356 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42357 _v = 0;
42358 PyErr_Clear();
42359 } else {
42360 _v = 1;
42361 }
42362 }
42363 if (_v) {
42364 {
42365 void *ptr;
42366 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42367 _v = 0;
42368 PyErr_Clear();
42369 } else {
42370 _v = 1;
42371 }
42372 }
42373 if (_v) {
42374 {
42375 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42376 }
42377 if (_v) {
42378 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
42379 }
42380 }
42381 }
42382 }
42383 if (argc == 3) {
42384 int _v;
42385 {
42386 void *ptr;
42387 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42388 _v = 0;
42389 PyErr_Clear();
42390 } else {
42391 _v = 1;
42392 }
42393 }
42394 if (_v) {
42395 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42396 if (_v) {
42397 {
42398 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42399 }
42400 if (_v) {
42401 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
42402 }
42403 }
42404 }
42405 }
42406
42407 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
42408 return NULL;
42409 }
42410
42411
42412 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
42413 PyObject *resultobj;
42414 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42415 wxWindow *arg2 = (wxWindow *) 0 ;
42416 wxGBSizerItem *result;
42417 PyObject * obj0 = 0 ;
42418 PyObject * obj1 = 0 ;
42419
42420 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42422 if (SWIG_arg_fail(1)) SWIG_fail;
42423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42424 if (SWIG_arg_fail(2)) SWIG_fail;
42425 {
42426 PyThreadState* __tstate = wxPyBeginAllowThreads();
42427 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42428
42429 wxPyEndAllowThreads(__tstate);
42430 if (PyErr_Occurred()) SWIG_fail;
42431 }
42432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42433 return resultobj;
42434 fail:
42435 return NULL;
42436 }
42437
42438
42439 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
42440 PyObject *resultobj;
42441 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42442 wxSizer *arg2 = (wxSizer *) 0 ;
42443 wxGBSizerItem *result;
42444 PyObject * obj0 = 0 ;
42445 PyObject * obj1 = 0 ;
42446
42447 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42449 if (SWIG_arg_fail(1)) SWIG_fail;
42450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42451 if (SWIG_arg_fail(2)) SWIG_fail;
42452 {
42453 PyThreadState* __tstate = wxPyBeginAllowThreads();
42454 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42455
42456 wxPyEndAllowThreads(__tstate);
42457 if (PyErr_Occurred()) SWIG_fail;
42458 }
42459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42460 return resultobj;
42461 fail:
42462 return NULL;
42463 }
42464
42465
42466 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
42467 int argc;
42468 PyObject *argv[3];
42469 int ii;
42470
42471 argc = PyObject_Length(args);
42472 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42473 argv[ii] = PyTuple_GetItem(args,ii);
42474 }
42475 if (argc == 2) {
42476 int _v;
42477 {
42478 void *ptr;
42479 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42480 _v = 0;
42481 PyErr_Clear();
42482 } else {
42483 _v = 1;
42484 }
42485 }
42486 if (_v) {
42487 {
42488 void *ptr;
42489 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42490 _v = 0;
42491 PyErr_Clear();
42492 } else {
42493 _v = 1;
42494 }
42495 }
42496 if (_v) {
42497 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
42498 }
42499 }
42500 }
42501 if (argc == 2) {
42502 int _v;
42503 {
42504 void *ptr;
42505 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42506 _v = 0;
42507 PyErr_Clear();
42508 } else {
42509 _v = 1;
42510 }
42511 }
42512 if (_v) {
42513 {
42514 void *ptr;
42515 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42516 _v = 0;
42517 PyErr_Clear();
42518 } else {
42519 _v = 1;
42520 }
42521 }
42522 if (_v) {
42523 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
42524 }
42525 }
42526 }
42527
42528 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
42529 return NULL;
42530 }
42531
42532
42533 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42534 PyObject *resultobj;
42535 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42536 wxGBPosition *arg2 = 0 ;
42537 wxGBSizerItem *result;
42538 wxGBPosition temp2 ;
42539 PyObject * obj0 = 0 ;
42540 PyObject * obj1 = 0 ;
42541 char *kwnames[] = {
42542 (char *) "self",(char *) "pos", NULL
42543 };
42544
42545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
42546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42547 if (SWIG_arg_fail(1)) SWIG_fail;
42548 {
42549 arg2 = &temp2;
42550 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42551 }
42552 {
42553 PyThreadState* __tstate = wxPyBeginAllowThreads();
42554 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
42555
42556 wxPyEndAllowThreads(__tstate);
42557 if (PyErr_Occurred()) SWIG_fail;
42558 }
42559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42560 return resultobj;
42561 fail:
42562 return NULL;
42563 }
42564
42565
42566 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
42567 PyObject *resultobj;
42568 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42569 wxPoint *arg2 = 0 ;
42570 wxGBSizerItem *result;
42571 wxPoint temp2 ;
42572 PyObject * obj0 = 0 ;
42573 PyObject * obj1 = 0 ;
42574 char *kwnames[] = {
42575 (char *) "self",(char *) "pt", NULL
42576 };
42577
42578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
42579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42580 if (SWIG_arg_fail(1)) SWIG_fail;
42581 {
42582 arg2 = &temp2;
42583 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
42584 }
42585 {
42586 PyThreadState* __tstate = wxPyBeginAllowThreads();
42587 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
42588
42589 wxPyEndAllowThreads(__tstate);
42590 if (PyErr_Occurred()) SWIG_fail;
42591 }
42592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42593 return resultobj;
42594 fail:
42595 return NULL;
42596 }
42597
42598
42599 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
42600 PyObject *resultobj;
42601 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42602 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42603 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
42604 bool result;
42605 PyObject * obj0 = 0 ;
42606 PyObject * obj1 = 0 ;
42607 PyObject * obj2 = 0 ;
42608 char *kwnames[] = {
42609 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
42610 };
42611
42612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
42613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42614 if (SWIG_arg_fail(1)) SWIG_fail;
42615 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42616 if (SWIG_arg_fail(2)) SWIG_fail;
42617 if (obj2) {
42618 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42619 if (SWIG_arg_fail(3)) SWIG_fail;
42620 }
42621 {
42622 PyThreadState* __tstate = wxPyBeginAllowThreads();
42623 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
42624
42625 wxPyEndAllowThreads(__tstate);
42626 if (PyErr_Occurred()) SWIG_fail;
42627 }
42628 {
42629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42630 }
42631 return resultobj;
42632 fail:
42633 return NULL;
42634 }
42635
42636
42637 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
42638 PyObject *resultobj;
42639 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42640 wxGBPosition *arg2 = 0 ;
42641 wxGBSpan *arg3 = 0 ;
42642 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
42643 bool result;
42644 wxGBPosition temp2 ;
42645 wxGBSpan temp3 ;
42646 PyObject * obj0 = 0 ;
42647 PyObject * obj1 = 0 ;
42648 PyObject * obj2 = 0 ;
42649 PyObject * obj3 = 0 ;
42650 char *kwnames[] = {
42651 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
42652 };
42653
42654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42656 if (SWIG_arg_fail(1)) SWIG_fail;
42657 {
42658 arg2 = &temp2;
42659 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42660 }
42661 {
42662 arg3 = &temp3;
42663 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42664 }
42665 if (obj3) {
42666 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42667 if (SWIG_arg_fail(4)) SWIG_fail;
42668 }
42669 {
42670 PyThreadState* __tstate = wxPyBeginAllowThreads();
42671 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
42672
42673 wxPyEndAllowThreads(__tstate);
42674 if (PyErr_Occurred()) SWIG_fail;
42675 }
42676 {
42677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42678 }
42679 return resultobj;
42680 fail:
42681 return NULL;
42682 }
42683
42684
42685 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
42686 PyObject *obj;
42687 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42688 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
42689 Py_INCREF(obj);
42690 return Py_BuildValue((char *)"");
42691 }
42692 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42693 PyObject *resultobj;
42694 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42695 wxRelationship arg2 ;
42696 wxWindow *arg3 = (wxWindow *) 0 ;
42697 wxEdge arg4 ;
42698 int arg5 = (int) 0 ;
42699 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
42700 PyObject * obj0 = 0 ;
42701 PyObject * obj1 = 0 ;
42702 PyObject * obj2 = 0 ;
42703 PyObject * obj3 = 0 ;
42704 PyObject * obj4 = 0 ;
42705 PyObject * obj5 = 0 ;
42706 char *kwnames[] = {
42707 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
42708 };
42709
42710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42712 if (SWIG_arg_fail(1)) SWIG_fail;
42713 {
42714 arg2 = (wxRelationship)(SWIG_As_int(obj1));
42715 if (SWIG_arg_fail(2)) SWIG_fail;
42716 }
42717 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42718 if (SWIG_arg_fail(3)) SWIG_fail;
42719 {
42720 arg4 = (wxEdge)(SWIG_As_int(obj3));
42721 if (SWIG_arg_fail(4)) SWIG_fail;
42722 }
42723 if (obj4) {
42724 {
42725 arg5 = (int)(SWIG_As_int(obj4));
42726 if (SWIG_arg_fail(5)) SWIG_fail;
42727 }
42728 }
42729 if (obj5) {
42730 {
42731 arg6 = (int)(SWIG_As_int(obj5));
42732 if (SWIG_arg_fail(6)) SWIG_fail;
42733 }
42734 }
42735 {
42736 PyThreadState* __tstate = wxPyBeginAllowThreads();
42737 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
42738
42739 wxPyEndAllowThreads(__tstate);
42740 if (PyErr_Occurred()) SWIG_fail;
42741 }
42742 Py_INCREF(Py_None); resultobj = Py_None;
42743 return resultobj;
42744 fail:
42745 return NULL;
42746 }
42747
42748
42749 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
42750 PyObject *resultobj;
42751 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42752 wxWindow *arg2 = (wxWindow *) 0 ;
42753 int arg3 = (int) 0 ;
42754 PyObject * obj0 = 0 ;
42755 PyObject * obj1 = 0 ;
42756 PyObject * obj2 = 0 ;
42757 char *kwnames[] = {
42758 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42759 };
42760
42761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
42762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42763 if (SWIG_arg_fail(1)) SWIG_fail;
42764 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42765 if (SWIG_arg_fail(2)) SWIG_fail;
42766 if (obj2) {
42767 {
42768 arg3 = (int)(SWIG_As_int(obj2));
42769 if (SWIG_arg_fail(3)) SWIG_fail;
42770 }
42771 }
42772 {
42773 PyThreadState* __tstate = wxPyBeginAllowThreads();
42774 (arg1)->LeftOf(arg2,arg3);
42775
42776 wxPyEndAllowThreads(__tstate);
42777 if (PyErr_Occurred()) SWIG_fail;
42778 }
42779 Py_INCREF(Py_None); resultobj = Py_None;
42780 return resultobj;
42781 fail:
42782 return NULL;
42783 }
42784
42785
42786 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
42787 PyObject *resultobj;
42788 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42789 wxWindow *arg2 = (wxWindow *) 0 ;
42790 int arg3 = (int) 0 ;
42791 PyObject * obj0 = 0 ;
42792 PyObject * obj1 = 0 ;
42793 PyObject * obj2 = 0 ;
42794 char *kwnames[] = {
42795 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42796 };
42797
42798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
42799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42800 if (SWIG_arg_fail(1)) SWIG_fail;
42801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42802 if (SWIG_arg_fail(2)) SWIG_fail;
42803 if (obj2) {
42804 {
42805 arg3 = (int)(SWIG_As_int(obj2));
42806 if (SWIG_arg_fail(3)) SWIG_fail;
42807 }
42808 }
42809 {
42810 PyThreadState* __tstate = wxPyBeginAllowThreads();
42811 (arg1)->RightOf(arg2,arg3);
42812
42813 wxPyEndAllowThreads(__tstate);
42814 if (PyErr_Occurred()) SWIG_fail;
42815 }
42816 Py_INCREF(Py_None); resultobj = Py_None;
42817 return resultobj;
42818 fail:
42819 return NULL;
42820 }
42821
42822
42823 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
42824 PyObject *resultobj;
42825 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42826 wxWindow *arg2 = (wxWindow *) 0 ;
42827 int arg3 = (int) 0 ;
42828 PyObject * obj0 = 0 ;
42829 PyObject * obj1 = 0 ;
42830 PyObject * obj2 = 0 ;
42831 char *kwnames[] = {
42832 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42833 };
42834
42835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
42836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42837 if (SWIG_arg_fail(1)) SWIG_fail;
42838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42839 if (SWIG_arg_fail(2)) SWIG_fail;
42840 if (obj2) {
42841 {
42842 arg3 = (int)(SWIG_As_int(obj2));
42843 if (SWIG_arg_fail(3)) SWIG_fail;
42844 }
42845 }
42846 {
42847 PyThreadState* __tstate = wxPyBeginAllowThreads();
42848 (arg1)->Above(arg2,arg3);
42849
42850 wxPyEndAllowThreads(__tstate);
42851 if (PyErr_Occurred()) SWIG_fail;
42852 }
42853 Py_INCREF(Py_None); resultobj = Py_None;
42854 return resultobj;
42855 fail:
42856 return NULL;
42857 }
42858
42859
42860 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
42861 PyObject *resultobj;
42862 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42863 wxWindow *arg2 = (wxWindow *) 0 ;
42864 int arg3 = (int) 0 ;
42865 PyObject * obj0 = 0 ;
42866 PyObject * obj1 = 0 ;
42867 PyObject * obj2 = 0 ;
42868 char *kwnames[] = {
42869 (char *) "self",(char *) "sibling",(char *) "marg", NULL
42870 };
42871
42872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
42873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42874 if (SWIG_arg_fail(1)) SWIG_fail;
42875 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42876 if (SWIG_arg_fail(2)) SWIG_fail;
42877 if (obj2) {
42878 {
42879 arg3 = (int)(SWIG_As_int(obj2));
42880 if (SWIG_arg_fail(3)) SWIG_fail;
42881 }
42882 }
42883 {
42884 PyThreadState* __tstate = wxPyBeginAllowThreads();
42885 (arg1)->Below(arg2,arg3);
42886
42887 wxPyEndAllowThreads(__tstate);
42888 if (PyErr_Occurred()) SWIG_fail;
42889 }
42890 Py_INCREF(Py_None); resultobj = Py_None;
42891 return resultobj;
42892 fail:
42893 return NULL;
42894 }
42895
42896
42897 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
42898 PyObject *resultobj;
42899 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42900 wxWindow *arg2 = (wxWindow *) 0 ;
42901 wxEdge arg3 ;
42902 int arg4 = (int) 0 ;
42903 PyObject * obj0 = 0 ;
42904 PyObject * obj1 = 0 ;
42905 PyObject * obj2 = 0 ;
42906 PyObject * obj3 = 0 ;
42907 char *kwnames[] = {
42908 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
42909 };
42910
42911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42913 if (SWIG_arg_fail(1)) SWIG_fail;
42914 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42915 if (SWIG_arg_fail(2)) SWIG_fail;
42916 {
42917 arg3 = (wxEdge)(SWIG_As_int(obj2));
42918 if (SWIG_arg_fail(3)) SWIG_fail;
42919 }
42920 if (obj3) {
42921 {
42922 arg4 = (int)(SWIG_As_int(obj3));
42923 if (SWIG_arg_fail(4)) SWIG_fail;
42924 }
42925 }
42926 {
42927 PyThreadState* __tstate = wxPyBeginAllowThreads();
42928 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
42929
42930 wxPyEndAllowThreads(__tstate);
42931 if (PyErr_Occurred()) SWIG_fail;
42932 }
42933 Py_INCREF(Py_None); resultobj = Py_None;
42934 return resultobj;
42935 fail:
42936 return NULL;
42937 }
42938
42939
42940 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
42941 PyObject *resultobj;
42942 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42943 wxWindow *arg2 = (wxWindow *) 0 ;
42944 wxEdge arg3 ;
42945 int arg4 ;
42946 PyObject * obj0 = 0 ;
42947 PyObject * obj1 = 0 ;
42948 PyObject * obj2 = 0 ;
42949 PyObject * obj3 = 0 ;
42950 char *kwnames[] = {
42951 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
42952 };
42953
42954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42956 if (SWIG_arg_fail(1)) SWIG_fail;
42957 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42958 if (SWIG_arg_fail(2)) SWIG_fail;
42959 {
42960 arg3 = (wxEdge)(SWIG_As_int(obj2));
42961 if (SWIG_arg_fail(3)) SWIG_fail;
42962 }
42963 {
42964 arg4 = (int)(SWIG_As_int(obj3));
42965 if (SWIG_arg_fail(4)) SWIG_fail;
42966 }
42967 {
42968 PyThreadState* __tstate = wxPyBeginAllowThreads();
42969 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
42970
42971 wxPyEndAllowThreads(__tstate);
42972 if (PyErr_Occurred()) SWIG_fail;
42973 }
42974 Py_INCREF(Py_None); resultobj = Py_None;
42975 return resultobj;
42976 fail:
42977 return NULL;
42978 }
42979
42980
42981 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
42982 PyObject *resultobj;
42983 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
42984 int arg2 ;
42985 PyObject * obj0 = 0 ;
42986 PyObject * obj1 = 0 ;
42987 char *kwnames[] = {
42988 (char *) "self",(char *) "val", NULL
42989 };
42990
42991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
42992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
42993 if (SWIG_arg_fail(1)) SWIG_fail;
42994 {
42995 arg2 = (int)(SWIG_As_int(obj1));
42996 if (SWIG_arg_fail(2)) SWIG_fail;
42997 }
42998 {
42999 PyThreadState* __tstate = wxPyBeginAllowThreads();
43000 (arg1)->Absolute(arg2);
43001
43002 wxPyEndAllowThreads(__tstate);
43003 if (PyErr_Occurred()) SWIG_fail;
43004 }
43005 Py_INCREF(Py_None); resultobj = Py_None;
43006 return resultobj;
43007 fail:
43008 return NULL;
43009 }
43010
43011
43012 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43013 PyObject *resultobj;
43014 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43015 PyObject * obj0 = 0 ;
43016 char *kwnames[] = {
43017 (char *) "self", NULL
43018 };
43019
43020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43022 if (SWIG_arg_fail(1)) SWIG_fail;
43023 {
43024 PyThreadState* __tstate = wxPyBeginAllowThreads();
43025 (arg1)->Unconstrained();
43026
43027 wxPyEndAllowThreads(__tstate);
43028 if (PyErr_Occurred()) SWIG_fail;
43029 }
43030 Py_INCREF(Py_None); resultobj = Py_None;
43031 return resultobj;
43032 fail:
43033 return NULL;
43034 }
43035
43036
43037 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43038 PyObject *resultobj;
43039 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43040 PyObject * obj0 = 0 ;
43041 char *kwnames[] = {
43042 (char *) "self", NULL
43043 };
43044
43045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43047 if (SWIG_arg_fail(1)) SWIG_fail;
43048 {
43049 PyThreadState* __tstate = wxPyBeginAllowThreads();
43050 (arg1)->AsIs();
43051
43052 wxPyEndAllowThreads(__tstate);
43053 if (PyErr_Occurred()) SWIG_fail;
43054 }
43055 Py_INCREF(Py_None); resultobj = Py_None;
43056 return resultobj;
43057 fail:
43058 return NULL;
43059 }
43060
43061
43062 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43063 PyObject *resultobj;
43064 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43065 wxWindow *result;
43066 PyObject * obj0 = 0 ;
43067 char *kwnames[] = {
43068 (char *) "self", NULL
43069 };
43070
43071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
43072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43073 if (SWIG_arg_fail(1)) SWIG_fail;
43074 {
43075 PyThreadState* __tstate = wxPyBeginAllowThreads();
43076 result = (wxWindow *)(arg1)->GetOtherWindow();
43077
43078 wxPyEndAllowThreads(__tstate);
43079 if (PyErr_Occurred()) SWIG_fail;
43080 }
43081 {
43082 resultobj = wxPyMake_wxObject(result, 0);
43083 }
43084 return resultobj;
43085 fail:
43086 return NULL;
43087 }
43088
43089
43090 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43091 PyObject *resultobj;
43092 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43093 wxEdge result;
43094 PyObject * obj0 = 0 ;
43095 char *kwnames[] = {
43096 (char *) "self", NULL
43097 };
43098
43099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
43100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43101 if (SWIG_arg_fail(1)) SWIG_fail;
43102 {
43103 PyThreadState* __tstate = wxPyBeginAllowThreads();
43104 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
43105
43106 wxPyEndAllowThreads(__tstate);
43107 if (PyErr_Occurred()) SWIG_fail;
43108 }
43109 resultobj = SWIG_From_int((result));
43110 return resultobj;
43111 fail:
43112 return NULL;
43113 }
43114
43115
43116 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43117 PyObject *resultobj;
43118 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43119 wxEdge arg2 ;
43120 PyObject * obj0 = 0 ;
43121 PyObject * obj1 = 0 ;
43122 char *kwnames[] = {
43123 (char *) "self",(char *) "which", NULL
43124 };
43125
43126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
43127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43128 if (SWIG_arg_fail(1)) SWIG_fail;
43129 {
43130 arg2 = (wxEdge)(SWIG_As_int(obj1));
43131 if (SWIG_arg_fail(2)) SWIG_fail;
43132 }
43133 {
43134 PyThreadState* __tstate = wxPyBeginAllowThreads();
43135 (arg1)->SetEdge((wxEdge )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_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43148 PyObject *resultobj;
43149 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43150 int arg2 ;
43151 PyObject * obj0 = 0 ;
43152 PyObject * obj1 = 0 ;
43153 char *kwnames[] = {
43154 (char *) "self",(char *) "v", NULL
43155 };
43156
43157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
43158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43159 if (SWIG_arg_fail(1)) SWIG_fail;
43160 {
43161 arg2 = (int)(SWIG_As_int(obj1));
43162 if (SWIG_arg_fail(2)) SWIG_fail;
43163 }
43164 {
43165 PyThreadState* __tstate = wxPyBeginAllowThreads();
43166 (arg1)->SetValue(arg2);
43167
43168 wxPyEndAllowThreads(__tstate);
43169 if (PyErr_Occurred()) SWIG_fail;
43170 }
43171 Py_INCREF(Py_None); resultobj = Py_None;
43172 return resultobj;
43173 fail:
43174 return NULL;
43175 }
43176
43177
43178 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43179 PyObject *resultobj;
43180 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43181 int result;
43182 PyObject * obj0 = 0 ;
43183 char *kwnames[] = {
43184 (char *) "self", NULL
43185 };
43186
43187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
43188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43189 if (SWIG_arg_fail(1)) SWIG_fail;
43190 {
43191 PyThreadState* __tstate = wxPyBeginAllowThreads();
43192 result = (int)(arg1)->GetMargin();
43193
43194 wxPyEndAllowThreads(__tstate);
43195 if (PyErr_Occurred()) SWIG_fail;
43196 }
43197 {
43198 resultobj = SWIG_From_int((int)(result));
43199 }
43200 return resultobj;
43201 fail:
43202 return NULL;
43203 }
43204
43205
43206 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43207 PyObject *resultobj;
43208 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43209 int arg2 ;
43210 PyObject * obj0 = 0 ;
43211 PyObject * obj1 = 0 ;
43212 char *kwnames[] = {
43213 (char *) "self",(char *) "m", NULL
43214 };
43215
43216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
43217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43218 if (SWIG_arg_fail(1)) SWIG_fail;
43219 {
43220 arg2 = (int)(SWIG_As_int(obj1));
43221 if (SWIG_arg_fail(2)) SWIG_fail;
43222 }
43223 {
43224 PyThreadState* __tstate = wxPyBeginAllowThreads();
43225 (arg1)->SetMargin(arg2);
43226
43227 wxPyEndAllowThreads(__tstate);
43228 if (PyErr_Occurred()) SWIG_fail;
43229 }
43230 Py_INCREF(Py_None); resultobj = Py_None;
43231 return resultobj;
43232 fail:
43233 return NULL;
43234 }
43235
43236
43237 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43238 PyObject *resultobj;
43239 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43240 int result;
43241 PyObject * obj0 = 0 ;
43242 char *kwnames[] = {
43243 (char *) "self", NULL
43244 };
43245
43246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
43247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43248 if (SWIG_arg_fail(1)) SWIG_fail;
43249 {
43250 PyThreadState* __tstate = wxPyBeginAllowThreads();
43251 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
43252
43253 wxPyEndAllowThreads(__tstate);
43254 if (PyErr_Occurred()) SWIG_fail;
43255 }
43256 {
43257 resultobj = SWIG_From_int((int)(result));
43258 }
43259 return resultobj;
43260 fail:
43261 return NULL;
43262 }
43263
43264
43265 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
43266 PyObject *resultobj;
43267 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43268 int result;
43269 PyObject * obj0 = 0 ;
43270 char *kwnames[] = {
43271 (char *) "self", NULL
43272 };
43273
43274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
43275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43276 if (SWIG_arg_fail(1)) SWIG_fail;
43277 {
43278 PyThreadState* __tstate = wxPyBeginAllowThreads();
43279 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
43280
43281 wxPyEndAllowThreads(__tstate);
43282 if (PyErr_Occurred()) SWIG_fail;
43283 }
43284 {
43285 resultobj = SWIG_From_int((int)(result));
43286 }
43287 return resultobj;
43288 fail:
43289 return NULL;
43290 }
43291
43292
43293 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43294 PyObject *resultobj;
43295 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43296 int result;
43297 PyObject * obj0 = 0 ;
43298 char *kwnames[] = {
43299 (char *) "self", NULL
43300 };
43301
43302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
43303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43304 if (SWIG_arg_fail(1)) SWIG_fail;
43305 {
43306 PyThreadState* __tstate = wxPyBeginAllowThreads();
43307 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
43308
43309 wxPyEndAllowThreads(__tstate);
43310 if (PyErr_Occurred()) SWIG_fail;
43311 }
43312 {
43313 resultobj = SWIG_From_int((int)(result));
43314 }
43315 return resultobj;
43316 fail:
43317 return NULL;
43318 }
43319
43320
43321 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43322 PyObject *resultobj;
43323 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43324 bool result;
43325 PyObject * obj0 = 0 ;
43326 char *kwnames[] = {
43327 (char *) "self", NULL
43328 };
43329
43330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
43331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43332 if (SWIG_arg_fail(1)) SWIG_fail;
43333 {
43334 PyThreadState* __tstate = wxPyBeginAllowThreads();
43335 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
43336
43337 wxPyEndAllowThreads(__tstate);
43338 if (PyErr_Occurred()) SWIG_fail;
43339 }
43340 {
43341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43342 }
43343 return resultobj;
43344 fail:
43345 return NULL;
43346 }
43347
43348
43349 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43350 PyObject *resultobj;
43351 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43352 bool arg2 ;
43353 PyObject * obj0 = 0 ;
43354 PyObject * obj1 = 0 ;
43355 char *kwnames[] = {
43356 (char *) "self",(char *) "d", NULL
43357 };
43358
43359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
43360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43361 if (SWIG_arg_fail(1)) SWIG_fail;
43362 {
43363 arg2 = (bool)(SWIG_As_bool(obj1));
43364 if (SWIG_arg_fail(2)) SWIG_fail;
43365 }
43366 {
43367 PyThreadState* __tstate = wxPyBeginAllowThreads();
43368 (arg1)->SetDone(arg2);
43369
43370 wxPyEndAllowThreads(__tstate);
43371 if (PyErr_Occurred()) SWIG_fail;
43372 }
43373 Py_INCREF(Py_None); resultobj = Py_None;
43374 return resultobj;
43375 fail:
43376 return NULL;
43377 }
43378
43379
43380 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43381 PyObject *resultobj;
43382 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43383 wxRelationship result;
43384 PyObject * obj0 = 0 ;
43385 char *kwnames[] = {
43386 (char *) "self", NULL
43387 };
43388
43389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
43390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43391 if (SWIG_arg_fail(1)) SWIG_fail;
43392 {
43393 PyThreadState* __tstate = wxPyBeginAllowThreads();
43394 result = (wxRelationship)(arg1)->GetRelationship();
43395
43396 wxPyEndAllowThreads(__tstate);
43397 if (PyErr_Occurred()) SWIG_fail;
43398 }
43399 resultobj = SWIG_From_int((result));
43400 return resultobj;
43401 fail:
43402 return NULL;
43403 }
43404
43405
43406 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43407 PyObject *resultobj;
43408 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43409 wxRelationship arg2 ;
43410 PyObject * obj0 = 0 ;
43411 PyObject * obj1 = 0 ;
43412 char *kwnames[] = {
43413 (char *) "self",(char *) "r", NULL
43414 };
43415
43416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
43417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43418 if (SWIG_arg_fail(1)) SWIG_fail;
43419 {
43420 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43421 if (SWIG_arg_fail(2)) SWIG_fail;
43422 }
43423 {
43424 PyThreadState* __tstate = wxPyBeginAllowThreads();
43425 (arg1)->SetRelationship((wxRelationship )arg2);
43426
43427 wxPyEndAllowThreads(__tstate);
43428 if (PyErr_Occurred()) SWIG_fail;
43429 }
43430 Py_INCREF(Py_None); resultobj = Py_None;
43431 return resultobj;
43432 fail:
43433 return NULL;
43434 }
43435
43436
43437 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
43438 PyObject *resultobj;
43439 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43440 wxWindow *arg2 = (wxWindow *) 0 ;
43441 bool result;
43442 PyObject * obj0 = 0 ;
43443 PyObject * obj1 = 0 ;
43444 char *kwnames[] = {
43445 (char *) "self",(char *) "otherW", NULL
43446 };
43447
43448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
43449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43450 if (SWIG_arg_fail(1)) SWIG_fail;
43451 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43452 if (SWIG_arg_fail(2)) SWIG_fail;
43453 {
43454 PyThreadState* __tstate = wxPyBeginAllowThreads();
43455 result = (bool)(arg1)->ResetIfWin(arg2);
43456
43457 wxPyEndAllowThreads(__tstate);
43458 if (PyErr_Occurred()) SWIG_fail;
43459 }
43460 {
43461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43462 }
43463 return resultobj;
43464 fail:
43465 return NULL;
43466 }
43467
43468
43469 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
43470 PyObject *resultobj;
43471 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43472 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
43473 wxWindow *arg3 = (wxWindow *) 0 ;
43474 bool result;
43475 PyObject * obj0 = 0 ;
43476 PyObject * obj1 = 0 ;
43477 PyObject * obj2 = 0 ;
43478 char *kwnames[] = {
43479 (char *) "self",(char *) "constraints",(char *) "win", NULL
43480 };
43481
43482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
43483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43484 if (SWIG_arg_fail(1)) SWIG_fail;
43485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43486 if (SWIG_arg_fail(2)) SWIG_fail;
43487 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43488 if (SWIG_arg_fail(3)) SWIG_fail;
43489 {
43490 PyThreadState* __tstate = wxPyBeginAllowThreads();
43491 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
43492
43493 wxPyEndAllowThreads(__tstate);
43494 if (PyErr_Occurred()) SWIG_fail;
43495 }
43496 {
43497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43498 }
43499 return resultobj;
43500 fail:
43501 return NULL;
43502 }
43503
43504
43505 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43506 PyObject *resultobj;
43507 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43508 wxEdge arg2 ;
43509 wxWindow *arg3 = (wxWindow *) 0 ;
43510 wxWindow *arg4 = (wxWindow *) 0 ;
43511 int result;
43512 PyObject * obj0 = 0 ;
43513 PyObject * obj1 = 0 ;
43514 PyObject * obj2 = 0 ;
43515 PyObject * obj3 = 0 ;
43516 char *kwnames[] = {
43517 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
43518 };
43519
43520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43522 if (SWIG_arg_fail(1)) SWIG_fail;
43523 {
43524 arg2 = (wxEdge)(SWIG_As_int(obj1));
43525 if (SWIG_arg_fail(2)) SWIG_fail;
43526 }
43527 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43528 if (SWIG_arg_fail(3)) SWIG_fail;
43529 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43530 if (SWIG_arg_fail(4)) SWIG_fail;
43531 {
43532 PyThreadState* __tstate = wxPyBeginAllowThreads();
43533 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
43534
43535 wxPyEndAllowThreads(__tstate);
43536 if (PyErr_Occurred()) SWIG_fail;
43537 }
43538 {
43539 resultobj = SWIG_From_int((int)(result));
43540 }
43541 return resultobj;
43542 fail:
43543 return NULL;
43544 }
43545
43546
43547 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
43548 PyObject *obj;
43549 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43550 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
43551 Py_INCREF(obj);
43552 return Py_BuildValue((char *)"");
43553 }
43554 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
43555 PyObject *resultobj;
43556 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43557 wxIndividualLayoutConstraint *result;
43558 PyObject * obj0 = 0 ;
43559 char *kwnames[] = {
43560 (char *) "self", NULL
43561 };
43562
43563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
43564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43565 if (SWIG_arg_fail(1)) SWIG_fail;
43566 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
43567
43568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43569 return resultobj;
43570 fail:
43571 return NULL;
43572 }
43573
43574
43575 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
43576 PyObject *resultobj;
43577 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43578 wxIndividualLayoutConstraint *result;
43579 PyObject * obj0 = 0 ;
43580 char *kwnames[] = {
43581 (char *) "self", NULL
43582 };
43583
43584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
43585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43586 if (SWIG_arg_fail(1)) SWIG_fail;
43587 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
43588
43589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43590 return resultobj;
43591 fail:
43592 return NULL;
43593 }
43594
43595
43596 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
43597 PyObject *resultobj;
43598 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43599 wxIndividualLayoutConstraint *result;
43600 PyObject * obj0 = 0 ;
43601 char *kwnames[] = {
43602 (char *) "self", NULL
43603 };
43604
43605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
43606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43607 if (SWIG_arg_fail(1)) SWIG_fail;
43608 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
43609
43610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43611 return resultobj;
43612 fail:
43613 return NULL;
43614 }
43615
43616
43617 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
43618 PyObject *resultobj;
43619 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43620 wxIndividualLayoutConstraint *result;
43621 PyObject * obj0 = 0 ;
43622 char *kwnames[] = {
43623 (char *) "self", NULL
43624 };
43625
43626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
43627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43628 if (SWIG_arg_fail(1)) SWIG_fail;
43629 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
43630
43631 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43632 return resultobj;
43633 fail:
43634 return NULL;
43635 }
43636
43637
43638 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
43639 PyObject *resultobj;
43640 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43641 wxIndividualLayoutConstraint *result;
43642 PyObject * obj0 = 0 ;
43643 char *kwnames[] = {
43644 (char *) "self", NULL
43645 };
43646
43647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
43648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43649 if (SWIG_arg_fail(1)) SWIG_fail;
43650 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
43651
43652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43653 return resultobj;
43654 fail:
43655 return NULL;
43656 }
43657
43658
43659 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
43660 PyObject *resultobj;
43661 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43662 wxIndividualLayoutConstraint *result;
43663 PyObject * obj0 = 0 ;
43664 char *kwnames[] = {
43665 (char *) "self", NULL
43666 };
43667
43668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
43669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43670 if (SWIG_arg_fail(1)) SWIG_fail;
43671 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
43672
43673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43674 return resultobj;
43675 fail:
43676 return NULL;
43677 }
43678
43679
43680 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
43681 PyObject *resultobj;
43682 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43683 wxIndividualLayoutConstraint *result;
43684 PyObject * obj0 = 0 ;
43685 char *kwnames[] = {
43686 (char *) "self", NULL
43687 };
43688
43689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
43690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43691 if (SWIG_arg_fail(1)) SWIG_fail;
43692 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
43693
43694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43695 return resultobj;
43696 fail:
43697 return NULL;
43698 }
43699
43700
43701 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
43702 PyObject *resultobj;
43703 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43704 wxIndividualLayoutConstraint *result;
43705 PyObject * obj0 = 0 ;
43706 char *kwnames[] = {
43707 (char *) "self", NULL
43708 };
43709
43710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
43711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43712 if (SWIG_arg_fail(1)) SWIG_fail;
43713 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
43714
43715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43716 return resultobj;
43717 fail:
43718 return NULL;
43719 }
43720
43721
43722 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43723 PyObject *resultobj;
43724 wxLayoutConstraints *result;
43725 char *kwnames[] = {
43726 NULL
43727 };
43728
43729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
43730 {
43731 PyThreadState* __tstate = wxPyBeginAllowThreads();
43732 result = (wxLayoutConstraints *)new wxLayoutConstraints();
43733
43734 wxPyEndAllowThreads(__tstate);
43735 if (PyErr_Occurred()) SWIG_fail;
43736 }
43737 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
43738 return resultobj;
43739 fail:
43740 return NULL;
43741 }
43742
43743
43744 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
43745 PyObject *resultobj;
43746 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43747 wxWindow *arg2 = (wxWindow *) 0 ;
43748 int *arg3 = (int *) 0 ;
43749 bool result;
43750 int temp3 ;
43751 int res3 = 0 ;
43752 PyObject * obj0 = 0 ;
43753 PyObject * obj1 = 0 ;
43754 char *kwnames[] = {
43755 (char *) "self",(char *) "win", NULL
43756 };
43757
43758 arg3 = &temp3; res3 = SWIG_NEWOBJ;
43759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
43760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43761 if (SWIG_arg_fail(1)) SWIG_fail;
43762 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43763 if (SWIG_arg_fail(2)) SWIG_fail;
43764 {
43765 PyThreadState* __tstate = wxPyBeginAllowThreads();
43766 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
43767
43768 wxPyEndAllowThreads(__tstate);
43769 if (PyErr_Occurred()) SWIG_fail;
43770 }
43771 {
43772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43773 }
43774 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
43775 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
43776 return resultobj;
43777 fail:
43778 return NULL;
43779 }
43780
43781
43782 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
43783 PyObject *resultobj;
43784 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43785 bool result;
43786 PyObject * obj0 = 0 ;
43787 char *kwnames[] = {
43788 (char *) "self", NULL
43789 };
43790
43791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
43792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43793 if (SWIG_arg_fail(1)) SWIG_fail;
43794 {
43795 PyThreadState* __tstate = wxPyBeginAllowThreads();
43796 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
43797
43798 wxPyEndAllowThreads(__tstate);
43799 if (PyErr_Occurred()) SWIG_fail;
43800 }
43801 {
43802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43803 }
43804 return resultobj;
43805 fail:
43806 return NULL;
43807 }
43808
43809
43810 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
43811 PyObject *obj;
43812 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43813 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
43814 Py_INCREF(obj);
43815 return Py_BuildValue((char *)"");
43816 }
43817 static PyMethodDef SwigMethods[] = {
43818 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
43819 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
43820 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
43821 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
43822 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
43823 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
43824 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
43825 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
43826 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
43827 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
43828 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
43829 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43830 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43831 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43832 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43833 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
43834 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
43835 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43836 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43837 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43838 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43839 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43840 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
43841 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
43842 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43843 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
43844 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43845 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43846 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43847 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43848 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43849 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43850 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43851 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43852 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43853 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43854 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43855 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43856 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
43857 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43858 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43859 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43860 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43861 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
43862 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
43863 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43864 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43865 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43866 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
43867 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43868 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
43869 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43870 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43871 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
43872 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
43873 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
43874 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
43875 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
43876 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
43877 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
43878 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
43879 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
43880 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
43881 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43882 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
43883 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43884 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
43885 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43886 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
43887 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
43888 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
43889 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43890 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43891 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
43892 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
43893 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43894 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
43895 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
43896 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
43897 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
43898 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
43899 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
43900 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
43901 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
43902 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
43903 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
43904 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
43905 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
43906 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
43907 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
43908 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43909 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43910 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43911 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
43912 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
43913 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
43914 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43915 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43916 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43917 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43918 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
43919 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
43920 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
43921 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
43922 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43923 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43924 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
43925 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
43926 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
43927 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
43928 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
43929 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
43930 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
43931 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
43932 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
43933 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
43934 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
43935 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
43936 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
43937 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
43938 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
43939 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
43940 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
43941 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
43942 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
43943 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
43944 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
43945 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
43946 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
43947 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
43948 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
43949 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
43950 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
43951 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
43952 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
43953 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
43954 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
43955 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
43956 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
43957 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
43958 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
43959 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
43960 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
43961 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
43962 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
43963 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
43964 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
43965 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
43966 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
43967 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
43968 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
43969 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
43970 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
43971 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
43972 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
43973 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
43974 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
43975 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
43976 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
43977 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
43978 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
43979 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
43980 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
43981 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
43982 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
43983 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
43984 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
43985 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
43986 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
43987 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
43988 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
43989 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
43990 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
43991 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
43992 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
43993 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
43994 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
43995 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
43996 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
43997 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
43998 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
43999 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44000 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44001 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44002 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44003 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44004 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44005 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44006 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44007 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44008 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44009 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44010 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44011 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44012 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44013 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44014 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44015 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44016 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44017 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44018 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44019 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44020 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44021 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44022 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44023 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44024 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44025 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44026 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44027 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44028 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44029 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44030 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44031 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44032 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44033 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44034 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44035 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44036 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44037 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44038 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44039 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44040 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44041 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44042 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44043 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44044 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44045 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44046 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44047 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44048 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44049 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44050 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44051 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44052 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44053 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44054 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44055 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44056 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44057 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44058 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44059 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44060 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44061 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44062 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44063 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
44064 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44065 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
44066 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44067 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
44068 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
44069 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44070 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44071 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44072 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44073 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44074 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
44075 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44076 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44077 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44078 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44079 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
44080 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
44081 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
44082 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
44083 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
44084 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44085 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44086 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44087 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44088 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44089 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44090 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
44091 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
44092 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44093 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44094 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
44095 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
44096 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
44097 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
44098 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
44099 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44100 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
44101 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44102 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44103 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44104 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44105 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
44106 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
44107 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44108 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44109 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44110 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44111 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
44112 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44113 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44114 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
44115 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44116 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
44117 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44118 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
44119 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44120 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
44121 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44122 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
44123 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44124 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
44125 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44126 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
44127 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44128 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
44129 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44130 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
44131 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44132 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
44133 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44134 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
44135 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44136 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
44137 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
44138 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
44139 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44140 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44141 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44142 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44143 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44144 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44145 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44146 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44147 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44148 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44149 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
44150 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
44151 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44152 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
44153 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44154 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
44155 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44156 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44157 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44158 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44159 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44160 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44161 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44162 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44163 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44164 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
44165 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
44166 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
44167 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44168 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44169 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44170 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
44171 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44172 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44173 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
44174 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44175 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44176 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
44177 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44178 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44179 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44180 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44181 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44182 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44183 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44184 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44185 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44186 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44187 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44188 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
44189 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44190 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44191 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
44192 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
44193 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
44194 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44195 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44196 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44197 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44198 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44199 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
44200 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44201 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44202 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44203 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44204 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44205 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
44206 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44207 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
44208 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
44209 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44210 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
44211 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
44212 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44213 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
44214 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44215 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44216 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44217 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44218 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44219 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44220 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
44221 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
44222 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
44223 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
44224 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
44225 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44226 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44227 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44228 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44229 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44230 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44231 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
44232 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
44233 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
44234 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
44235 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44236 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44237 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44238 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44239 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44240 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
44241 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
44242 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
44243 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
44244 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44245 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44246 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44247 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44248 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44249 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44250 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44251 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44252 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44253 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44254 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44255 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44256 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44257 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44258 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44259 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44260 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44261 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44262 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
44263 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
44264 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
44265 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
44266 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
44267 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
44268 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
44269 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44270 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44271 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44272 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44273 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44274 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44275 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
44276 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44277 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44278 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44279 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44280 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44281 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44282 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
44283 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44284 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44285 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44286 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44287 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44288 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44289 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44290 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44291 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44292 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44293 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44294 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44295 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44296 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44297 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44298 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44299 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44300 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44301 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44302 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44303 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44304 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44305 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44306 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44307 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44308 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44309 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
44310 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
44311 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
44312 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44313 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44314 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44315 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44316 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44317 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
44318 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
44319 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44320 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44321 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
44322 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44323 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44324 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44325 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44326 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44327 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
44328 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44329 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
44330 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44331 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
44332 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44333 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
44334 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
44335 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44336 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44337 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44338 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
44339 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44340 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44341 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
44342 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44343 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44344 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
44345 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44346 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
44347 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44348 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
44349 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
44350 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44351 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
44352 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44353 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44354 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44355 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44356 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44357 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44358 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44359 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
44360 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44361 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44362 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44363 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
44364 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44365 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
44366 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
44367 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44368 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
44369 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44370 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44371 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44372 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
44373 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44374 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44375 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44376 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44377 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
44378 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44379 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44380 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44381 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44382 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44383 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44384 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44385 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
44386 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
44387 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44388 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44389 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
44390 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44391 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
44392 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44393 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44394 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
44395 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44396 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
44397 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44398 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44399 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44400 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
44401 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44402 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44403 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44404 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
44405 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44406 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44407 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44408 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44409 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44410 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44411 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44412 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44413 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
44414 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44415 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44416 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
44417 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44418 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44419 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
44420 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44421 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44422 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44423 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
44424 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44425 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
44426 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
44427 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44428 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44429 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
44430 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
44431 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44432 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44433 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44434 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44435 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
44436 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44437 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44438 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44439 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44440 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
44441 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44442 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44443 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44444 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44445 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44446 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44447 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44448 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44449 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44450 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
44451 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44452 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44453 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44454 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44455 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44456 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44457 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44458 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44459 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44460 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44461 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44462 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
44463 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44464 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44465 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44466 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44467 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44468 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44469 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44470 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44471 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44472 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44473 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44474 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44475 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44476 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44477 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44478 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44479 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44480 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44481 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44482 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44483 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
44484 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
44485 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
44486 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44487 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44488 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
44489 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
44490 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44491 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44492 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
44493 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
44494 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44495 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44496 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44497 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44498 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
44499 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44500 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44501 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44502 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44503 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44504 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44505 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
44506 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44507 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44508 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44509 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44510 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44511 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
44512 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
44513 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44514 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44515 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44516 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
44517 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
44518 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44519 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44520 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
44521 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
44522 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44523 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44524 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44525 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44526 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
44527 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
44528 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44529 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44530 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
44531 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44532 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44533 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
44534 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44535 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44536 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44537 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44538 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44539 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44540 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44541 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44542 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44543 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44544 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44545 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44546 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44547 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44548 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
44549 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44550 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44551 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
44552 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
44553 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44554 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
44555 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
44556 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44557 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44558 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44559 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44560 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44561 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44562 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44563 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44564 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44565 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44566 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
44567 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44568 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44569 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44570 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44571 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44572 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44573 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
44574 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44575 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
44576 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
44577 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
44578 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44579 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44580 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44581 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44582 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44583 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44584 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44585 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44586 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44587 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44588 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44589 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44590 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44591 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44592 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44593 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44594 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44595 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44596 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
44597 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44598 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
44599 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44600 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44601 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44602 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44603 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44604 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
44605 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44606 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44607 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
44608 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44609 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44610 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44611 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
44612 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44613 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44614 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
44615 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44616 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44617 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44618 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
44619 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44620 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44621 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44622 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44623 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
44624 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
44625 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
44626 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
44627 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
44628 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44629 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44630 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44631 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44632 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44633 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44634 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44635 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44636 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44637 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44638 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44639 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44640 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44641 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44642 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44643 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44644 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44645 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44646 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44647 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
44648 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
44649 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44650 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44651 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
44652 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44653 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
44654 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44655 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
44656 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
44657 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
44658 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
44659 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
44660 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
44661 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
44662 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
44663 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
44664 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44665 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
44666 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44667 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
44668 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44669 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44670 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44671 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44672 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44673 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44674 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44675 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
44676 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44677 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44678 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
44679 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44680 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44681 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44682 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
44683 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
44684 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44685 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
44686 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44687 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44688 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44689 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
44690 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
44691 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
44692 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44693 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
44694 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
44695 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
44696 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
44697 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
44698 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
44699 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44700 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44701 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44702 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
44703 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44704 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
44705 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44706 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
44707 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
44708 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
44709 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44710 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
44711 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
44712 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
44713 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
44714 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
44715 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
44716 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44717 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
44718 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
44719 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
44720 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44721 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
44722 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44723 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
44724 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44725 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
44726 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
44727 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
44728 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
44729 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44730 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
44731 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44732 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44734 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44735 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
44736 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
44737 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44738 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44739 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44740 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
44741 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
44742 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44744 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44745 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44746 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44748 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
44749 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
44750 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
44751 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44752 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
44754 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44756 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44757 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44758 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44759 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
44761 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
44762 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44764 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44768 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
44772 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44775 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
44780 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
44785 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44789 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
44809 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
44834 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
44836 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44854 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
44861 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44865 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
44866 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
44874 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
44875 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
44891 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
44892 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
44929 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
44959 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
44962 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
44966 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
44969 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
44979 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
44991 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"StdDialogButtonSizer_Finalise", (PyCFunction) _wrap_StdDialogButtonSizer_Finalise, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45003 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45013 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45023 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
45037 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
45044 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
45045 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
45046 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
45047 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
45048 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
45053 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
45080 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45085 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
45092 { NULL, NULL, 0, NULL }
45093 };
45094
45095
45096 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
45097
45098 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
45099 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
45100 }
45101 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
45102 return (void *)((wxSizer *) ((wxBoxSizer *) x));
45103 }
45104 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
45105 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
45106 }
45107 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
45108 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45109 }
45110 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
45111 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45112 }
45113 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
45114 return (void *)((wxSizer *) ((wxGridSizer *) x));
45115 }
45116 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
45117 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
45118 }
45119 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
45120 return (void *)((wxSizer *) ((wxPySizer *) x));
45121 }
45122 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
45123 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
45124 }
45125 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
45126 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45127 }
45128 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
45129 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
45130 }
45131 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
45132 return (void *)((wxEvent *) ((wxMenuEvent *) x));
45133 }
45134 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
45135 return (void *)((wxEvent *) ((wxCloseEvent *) x));
45136 }
45137 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
45138 return (void *)((wxEvent *) ((wxMouseEvent *) x));
45139 }
45140 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
45141 return (void *)((wxEvent *) ((wxEraseEvent *) x));
45142 }
45143 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
45144 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
45145 }
45146 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
45147 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
45148 }
45149 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
45150 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
45151 }
45152 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
45153 return (void *)((wxEvent *) ((wxPyEvent *) x));
45154 }
45155 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
45156 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
45157 }
45158 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
45159 return (void *)((wxEvent *) ((wxIdleEvent *) x));
45160 }
45161 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
45162 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
45163 }
45164 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
45165 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
45166 }
45167 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
45168 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
45169 }
45170 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
45171 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
45172 }
45173 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
45174 return (void *)((wxEvent *) ((wxActivateEvent *) x));
45175 }
45176 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
45177 return (void *)((wxEvent *) ((wxSizeEvent *) x));
45178 }
45179 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
45180 return (void *)((wxEvent *) ((wxMoveEvent *) x));
45181 }
45182 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
45183 return (void *)((wxEvent *) ((wxPaintEvent *) x));
45184 }
45185 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
45186 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
45187 }
45188 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
45189 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
45190 }
45191 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
45192 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
45193 }
45194 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
45195 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
45196 }
45197 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
45198 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45199 }
45200 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
45201 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
45202 }
45203 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
45204 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
45205 }
45206 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
45207 return (void *)((wxEvent *) ((wxFocusEvent *) x));
45208 }
45209 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
45210 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
45211 }
45212 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
45213 return (void *)((wxEvent *) ((wxShowEvent *) x));
45214 }
45215 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
45216 return (void *)((wxEvent *) ((wxCommandEvent *) x));
45217 }
45218 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
45219 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
45220 }
45221 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
45222 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45223 }
45224 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
45225 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
45226 }
45227 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
45228 return (void *)((wxEvent *) ((wxKeyEvent *) x));
45229 }
45230 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
45231 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
45232 }
45233 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
45234 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
45235 }
45236 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
45237 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
45238 }
45239 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
45240 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
45241 }
45242 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
45243 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
45244 }
45245 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
45246 return (void *)((wxControl *) ((wxControlWithItems *) x));
45247 }
45248 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
45249 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
45250 }
45251 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
45252 return (void *)((wxEvtHandler *) ((wxWindow *) x));
45253 }
45254 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
45255 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45256 }
45257 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
45258 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
45259 }
45260 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
45261 return (void *)((wxEvtHandler *) ((wxValidator *) x));
45262 }
45263 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
45264 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
45265 }
45266 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
45267 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
45268 }
45269 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
45270 return (void *)((wxEvtHandler *) ((wxMenu *) x));
45271 }
45272 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
45273 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
45274 }
45275 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
45276 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
45277 }
45278 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
45279 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
45280 }
45281 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
45282 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
45283 }
45284 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
45285 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
45286 }
45287 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
45288 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45289 }
45290 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
45291 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
45292 }
45293 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
45294 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
45295 }
45296 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
45297 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45298 }
45299 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
45300 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45301 }
45302 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
45303 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
45304 }
45305 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
45306 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
45307 }
45308 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
45309 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
45310 }
45311 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
45312 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
45313 }
45314 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
45315 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
45316 }
45317 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
45318 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
45319 }
45320 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
45321 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
45322 }
45323 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
45324 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
45325 }
45326 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
45327 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
45328 }
45329 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
45330 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
45331 }
45332 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
45333 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
45334 }
45335 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
45336 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
45337 }
45338 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
45339 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
45340 }
45341 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
45342 return (void *)((wxObject *) ((wxSizerItem *) x));
45343 }
45344 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
45345 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
45346 }
45347 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
45348 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
45349 }
45350 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
45351 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
45352 }
45353 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
45354 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
45355 }
45356 static void *_p_wxSizerTo_p_wxObject(void *x) {
45357 return (void *)((wxObject *) ((wxSizer *) x));
45358 }
45359 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
45360 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45361 }
45362 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
45363 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
45364 }
45365 static void *_p_wxEventTo_p_wxObject(void *x) {
45366 return (void *)((wxObject *) ((wxEvent *) x));
45367 }
45368 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
45369 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
45370 }
45371 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
45372 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
45373 }
45374 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
45375 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
45376 }
45377 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
45378 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
45379 }
45380 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
45381 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
45382 }
45383 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
45384 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
45385 }
45386 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
45387 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
45388 }
45389 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
45390 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45391 }
45392 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
45393 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
45394 }
45395 static void *_p_wxControlTo_p_wxObject(void *x) {
45396 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
45397 }
45398 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
45399 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
45400 }
45401 static void *_p_wxFSFileTo_p_wxObject(void *x) {
45402 return (void *)((wxObject *) ((wxFSFile *) x));
45403 }
45404 static void *_p_wxPySizerTo_p_wxObject(void *x) {
45405 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
45406 }
45407 static void *_p_wxPyEventTo_p_wxObject(void *x) {
45408 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
45409 }
45410 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
45411 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
45412 }
45413 static void *_p_wxShowEventTo_p_wxObject(void *x) {
45414 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
45415 }
45416 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
45417 return (void *)((wxObject *) ((wxMenuItem *) x));
45418 }
45419 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
45420 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
45421 }
45422 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
45423 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
45424 }
45425 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
45426 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
45427 }
45428 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
45429 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
45430 }
45431 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
45432 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
45433 }
45434 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
45435 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
45436 }
45437 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
45438 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
45439 }
45440 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
45441 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
45442 }
45443 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
45444 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
45445 }
45446 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
45447 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
45448 }
45449 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
45450 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
45451 }
45452 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
45453 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
45454 }
45455 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
45456 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
45457 }
45458 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
45459 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
45460 }
45461 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
45462 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45463 }
45464 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
45465 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45466 }
45467 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
45468 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
45469 }
45470 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
45471 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
45472 }
45473 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
45474 return (void *)((wxObject *) ((wxImageHandler *) x));
45475 }
45476 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
45477 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
45478 }
45479 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
45480 return (void *)((wxObject *) ((wxEvtHandler *) x));
45481 }
45482 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
45483 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45484 }
45485 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
45486 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
45487 }
45488 static void *_p_wxImageTo_p_wxObject(void *x) {
45489 return (void *)((wxObject *) ((wxImage *) x));
45490 }
45491 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
45492 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
45493 }
45494 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
45495 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45496 }
45497 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
45498 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
45499 }
45500 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
45501 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
45502 }
45503 static void *_p_wxWindowTo_p_wxObject(void *x) {
45504 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
45505 }
45506 static void *_p_wxMenuTo_p_wxObject(void *x) {
45507 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
45508 }
45509 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
45510 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
45511 }
45512 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
45513 return (void *)((wxObject *) ((wxFileSystem *) x));
45514 }
45515 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
45516 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
45517 }
45518 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
45519 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
45520 }
45521 static void *_p_wxPyAppTo_p_wxObject(void *x) {
45522 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
45523 }
45524 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
45525 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
45526 }
45527 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
45528 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
45529 }
45530 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
45531 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
45532 }
45533 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
45534 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
45535 }
45536 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
45537 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
45538 }
45539 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
45540 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
45541 }
45542 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
45543 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
45544 }
45545 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
45546 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
45547 }
45548 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
45549 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45550 }
45551 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
45552 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
45553 }
45554 static void *_p_wxValidatorTo_p_wxObject(void *x) {
45555 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
45556 }
45557 static void *_p_wxControlTo_p_wxWindow(void *x) {
45558 return (void *)((wxWindow *) ((wxControl *) x));
45559 }
45560 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
45561 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
45562 }
45563 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
45564 return (void *)((wxWindow *) ((wxMenuBar *) x));
45565 }
45566 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
45567 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
45568 }
45569 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
45570 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
45571 }
45572 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
45573 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
45574 }
45575 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
45576 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
45577 }
45578 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
45579 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45580 }
45581 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
45582 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
45583 }
45584 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
45585 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
45586 }
45587 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
45588 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
45589 }
45590 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
45591 return (void *)((wxValidator *) ((wxPyValidator *) x));
45592 }
45593 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}};
45594 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}};
45595 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}};
45596 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}};
45597 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}};
45598 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}};
45599 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}};
45600 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}};
45601 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}};
45602 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}};
45603 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}};
45604 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}};
45605 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}};
45606 static swig_type_info _swigt__p_wxEvent[] = {{"_p_wxEvent", 0, "wxEvent *", 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxEvent", 0, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxEvent, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45607 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}};
45608 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}};
45609 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}};
45610 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}};
45611 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}};
45612 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}};
45613 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}};
45614 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}};
45615 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}};
45616 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}};
45617 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}};
45618 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}};
45619 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}};
45620 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}};
45621 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}};
45622 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}};
45623 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}};
45624 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}};
45625 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}};
45626 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}};
45627 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}};
45628 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}};
45629 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}};
45630 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}};
45631 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}};
45632 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}};
45633 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}};
45634 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}};
45635 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}};
45636 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}};
45637 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}};
45638 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}};
45639 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}};
45640 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}};
45641 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}};
45642 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}};
45643 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}};
45644 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}};
45645 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}};
45646 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}};
45647 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}};
45648 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}};
45649 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}};
45650 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}};
45651 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}};
45652 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}};
45653 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}};
45654 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}};
45655 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}};
45656 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}};
45657 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}};
45658 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}};
45659 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}};
45660 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}};
45661 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}};
45662 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}};
45663 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}};
45664 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}};
45665 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}};
45666 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}};
45667 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}};
45668 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}};
45669 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}};
45670 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}};
45671 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}};
45672 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}};
45673 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}};
45674 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}};
45675 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}};
45676 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}};
45677 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}};
45678 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}};
45679 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}};
45680 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}};
45681 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}};
45682 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}};
45683 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}};
45684 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}};
45685 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}};
45686 static swig_type_info _swigt__p_wxObject[] = {{"_p_wxObject", 0, "wxObject *", 0, 0, 0, 0},{"_p_wxLayoutConstraints", _p_wxLayoutConstraintsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGBSizerItem", _p_wxGBSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizerItem", _p_wxSizerItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIndividualLayoutConstraint", _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStaticBoxSizer", _p_wxStaticBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBoxSizer", _p_wxBoxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizer", _p_wxSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridBagSizer", _p_wxGridBagSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenu", _p_wxMenuTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvent", _p_wxEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFlexGridSizer", _p_wxFlexGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGridSizer", _p_wxGridSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxInitDialogEvent", _p_wxInitDialogEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaintEvent", _p_wxPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNcPaintEvent", _p_wxNcPaintEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPaletteChangedEvent", _p_wxPaletteChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDisplayChangedEvent", _p_wxDisplayChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseCaptureChangedEvent", _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSysColourChangedEvent", _p_wxSysColourChangedEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControl", _p_wxControlTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSetCursorEvent", _p_wxSetCursorEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFSFile", _p_wxFSFileTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPySizer", _p_wxPySizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyEvent", _p_wxPyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxShowEvent", _p_wxShowEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuItem", _p_wxMenuItemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMoveEvent", _p_wxMoveEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxSizeEvent", _p_wxSizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxActivateEvent", _p_wxActivateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIconizeEvent", _p_wxIconizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMaximizeEvent", _p_wxMaximizeEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxIdleEvent", _p_wxIdleEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxQueryNewPaletteEvent", _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxXPMHandler", _p_wxXPMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNMHandler", _p_wxPNMHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxJPEGHandler", _p_wxJPEGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPCXHandler", _p_wxPCXHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxGIFHandler", _p_wxGIFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPNGHandler", _p_wxPNGHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxANIHandler", _p_wxANIHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCURHandler", _p_wxCURHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxICOHandler", _p_wxICOHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxBMPHandler", _p_wxBMPHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImageHandler", _p_wxImageHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxTIFFHandler", _p_wxTIFFHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEvtHandler", _p_wxEvtHandlerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxStdDialogButtonSizer", _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxAcceleratorTable", _p_wxAcceleratorTableTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxImage", _p_wxImageTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxScrollWinEvent", _p_wxScrollWinEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxObject", 0, 0, 0, 0, 0, 0},{"_p_wxKeyEvent", _p_wxKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxNavigationKeyEvent", _p_wxNavigationKeyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxWindow", _p_wxWindowTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuBar", _p_wxMenuBarTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFileSystem", _p_wxFileSystemTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMenuEvent", _p_wxMenuEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyApp", _p_wxPyAppTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCloseEvent", _p_wxCloseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxMouseEvent", _p_wxMouseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxEraseEvent", _p_wxEraseEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", _p_wxCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxDropFilesEvent", _p_wxDropFilesEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxFocusEvent", _p_wxFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxControlWithItems", _p_wxControlWithItemsTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxPyValidator", _p_wxPyValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{"_p_wxValidator", _p_wxValidatorTo_p_wxObject, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45687 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}};
45688 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}};
45689 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}};
45690 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}};
45691 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}};
45692 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}};
45693 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}};
45694 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}};
45695 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}};
45696 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}};
45697 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}};
45698 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}};
45699 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}};
45700 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}};
45701 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}};
45702 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}};
45703 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}};
45704 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}};
45705 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}};
45706 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}};
45707 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}};
45708 static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0, 0, 0, 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxCommandEvent", 0, 0, 0, 0, 0, 0},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
45709 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}};
45710 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}};
45711 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}};
45712 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}};
45713 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}};
45714 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}};
45715 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}};
45716 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}};
45717 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}};
45718 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}};
45719
45720 static swig_type_info *swig_types_initial[] = {
45721 _swigt__p_wxLayoutConstraints,
45722 _swigt__p_wxRealPoint,
45723 _swigt__p_wxSizerItem,
45724 _swigt__p_wxGBSizerItem,
45725 _swigt__p_wxScrollEvent,
45726 _swigt__p_wxEventLoop,
45727 _swigt__p_wxIndividualLayoutConstraint,
45728 _swigt__p_wxSizer,
45729 _swigt__p_wxBoxSizer,
45730 _swigt__p_wxStaticBoxSizer,
45731 _swigt__p_wxGridBagSizer,
45732 _swigt__p_wxAcceleratorEntry,
45733 _swigt__p_wxUpdateUIEvent,
45734 _swigt__p_wxEvent,
45735 _swigt__p_wxMenu,
45736 _swigt__p_wxGridSizer,
45737 _swigt__p_wxFlexGridSizer,
45738 _swigt__p_wxInitDialogEvent,
45739 _swigt__p_wxItemContainer,
45740 _swigt__p_wxNcPaintEvent,
45741 _swigt__p_wxPaintEvent,
45742 _swigt__p_wxSysColourChangedEvent,
45743 _swigt__p_wxMouseCaptureChangedEvent,
45744 _swigt__p_wxDisplayChangedEvent,
45745 _swigt__p_wxPaletteChangedEvent,
45746 _swigt__p_wxControl,
45747 _swigt__p_wxFont,
45748 _swigt__p_wxMenuBarBase,
45749 _swigt__p_wxSetCursorEvent,
45750 _swigt__p_wxFSFile,
45751 _swigt__p_wxCaret,
45752 _swigt__ptrdiff_t,
45753 _swigt__std__ptrdiff_t,
45754 _swigt__p_wxRegion,
45755 _swigt__p_wxPoint2D,
45756 _swigt__p_int,
45757 _swigt__p_wxSize,
45758 _swigt__p_wxDC,
45759 _swigt__p_wxPySizer,
45760 _swigt__p_wxVisualAttributes,
45761 _swigt__p_wxNotifyEvent,
45762 _swigt__p_wxPyEvent,
45763 _swigt__p_wxPropagationDisabler,
45764 _swigt__p_form_ops_t,
45765 _swigt__p_wxAppTraits,
45766 _swigt__p_wxArrayString,
45767 _swigt__p_wxShowEvent,
45768 _swigt__p_wxToolTip,
45769 _swigt__p_wxMoveEvent,
45770 _swigt__p_wxSizeEvent,
45771 _swigt__p_wxActivateEvent,
45772 _swigt__p_wxIconizeEvent,
45773 _swigt__p_wxMaximizeEvent,
45774 _swigt__p_wxQueryNewPaletteEvent,
45775 _swigt__p_wxWindowCreateEvent,
45776 _swigt__p_wxIdleEvent,
45777 _swigt__p_wxMenuItem,
45778 _swigt__p_wxStaticBox,
45779 _swigt__p_long,
45780 _swigt__p_wxDuplexMode,
45781 _swigt__p_wxTIFFHandler,
45782 _swigt__p_wxXPMHandler,
45783 _swigt__p_wxPNMHandler,
45784 _swigt__p_wxJPEGHandler,
45785 _swigt__p_wxPCXHandler,
45786 _swigt__p_wxGIFHandler,
45787 _swigt__p_wxPNGHandler,
45788 _swigt__p_wxANIHandler,
45789 _swigt__p_wxMemoryFSHandler,
45790 _swigt__p_wxZipFSHandler,
45791 _swigt__p_wxInternetFSHandler,
45792 _swigt__p_wxPyFileSystemHandler,
45793 _swigt__p_wxEvtHandler,
45794 _swigt__p_wxCURHandler,
45795 _swigt__p_wxICOHandler,
45796 _swigt__p_wxBMPHandler,
45797 _swigt__p_wxImageHandler,
45798 _swigt__p_wxFileSystemHandler,
45799 _swigt__p_wxRect,
45800 _swigt__p_wxButton,
45801 _swigt__p_wxGBSpan,
45802 _swigt__p_wxPropagateOnce,
45803 _swigt__p_wxAcceleratorTable,
45804 _swigt__p_wxStdDialogButtonSizer,
45805 _swigt__p_char,
45806 _swigt__p_wxGBPosition,
45807 _swigt__p_wxImage,
45808 _swigt__p_wxFrame,
45809 _swigt__p_wxScrollWinEvent,
45810 _swigt__p_wxPaperSize,
45811 _swigt__p_wxImageHistogram,
45812 _swigt__p_wxPoint,
45813 _swigt__p_wxCursor,
45814 _swigt__p_wxObject,
45815 _swigt__p_wxInputStream,
45816 _swigt__p_wxOutputStream,
45817 _swigt__p_wxPyInputStream,
45818 _swigt__p_wxDateTime,
45819 _swigt__p_wxKeyEvent,
45820 _swigt__p_wxNavigationKeyEvent,
45821 _swigt__p_wxWindowDestroyEvent,
45822 _swigt__p_unsigned_long,
45823 _swigt__p_wxWindow,
45824 _swigt__p_wxMenuBar,
45825 _swigt__p_wxFileSystem,
45826 _swigt__p_wxBitmap,
45827 _swigt__unsigned_int,
45828 _swigt__p_unsigned_int,
45829 _swigt__p_wxMenuEvent,
45830 _swigt__p_wxContextMenuEvent,
45831 _swigt__p_unsigned_char,
45832 _swigt__p_wxEraseEvent,
45833 _swigt__p_wxMouseEvent,
45834 _swigt__p_wxCloseEvent,
45835 _swigt__p_wxPyApp,
45836 _swigt__p_wxCommandEvent,
45837 _swigt__p_wxPyCommandEvent,
45838 _swigt__p_wxPyDropTarget,
45839 _swigt__p_wxQuantize,
45840 _swigt__p_wxChildFocusEvent,
45841 _swigt__p_wxFocusEvent,
45842 _swigt__p_wxDropFilesEvent,
45843 _swigt__p_wxControlWithItems,
45844 _swigt__p_wxColour,
45845 _swigt__p_wxValidator,
45846 _swigt__p_wxPyValidator,
45847 0
45848 };
45849
45850
45851 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
45852
45853 static swig_const_info swig_const_table[] = {
45854 {0, 0, 0, 0.0, 0, 0}};
45855
45856 #ifdef __cplusplus
45857 }
45858 #endif
45859
45860
45861 #ifdef __cplusplus
45862 extern "C" {
45863 #endif
45864
45865 /* Python-specific SWIG API */
45866 #define SWIG_newvarlink() SWIG_Python_newvarlink()
45867 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
45868 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
45869
45870 /* -----------------------------------------------------------------------------
45871 * global variable support code.
45872 * ----------------------------------------------------------------------------- */
45873
45874 typedef struct swig_globalvar {
45875 char *name; /* Name of global variable */
45876 PyObject *(*get_attr)(); /* Return the current value */
45877 int (*set_attr)(PyObject *); /* Set the value */
45878 struct swig_globalvar *next;
45879 } swig_globalvar;
45880
45881 typedef struct swig_varlinkobject {
45882 PyObject_HEAD
45883 swig_globalvar *vars;
45884 } swig_varlinkobject;
45885
45886 static PyObject *
45887 swig_varlink_repr(swig_varlinkobject *v) {
45888 v = v;
45889 return PyString_FromString("<Swig global variables>");
45890 }
45891
45892 static int
45893 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
45894 swig_globalvar *var;
45895 flags = flags;
45896 fprintf(fp,"Swig global variables { ");
45897 for (var = v->vars; var; var=var->next) {
45898 fprintf(fp,"%s", var->name);
45899 if (var->next) fprintf(fp,", ");
45900 }
45901 fprintf(fp," }\n");
45902 return 0;
45903 }
45904
45905 static PyObject *
45906 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
45907 swig_globalvar *var = v->vars;
45908 while (var) {
45909 if (strcmp(var->name,n) == 0) {
45910 return (*var->get_attr)();
45911 }
45912 var = var->next;
45913 }
45914 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
45915 return NULL;
45916 }
45917
45918 static int
45919 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
45920 swig_globalvar *var = v->vars;
45921 while (var) {
45922 if (strcmp(var->name,n) == 0) {
45923 return (*var->set_attr)(p);
45924 }
45925 var = var->next;
45926 }
45927 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
45928 return 1;
45929 }
45930
45931 static PyTypeObject varlinktype = {
45932 PyObject_HEAD_INIT(0)
45933 0, /* Number of items in variable part (ob_size) */
45934 (char *)"swigvarlink", /* Type name (tp_name) */
45935 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
45936 0, /* Itemsize (tp_itemsize) */
45937 0, /* Deallocator (tp_dealloc) */
45938 (printfunc) swig_varlink_print, /* Print (tp_print) */
45939 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
45940 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
45941 0, /* tp_compare */
45942 (reprfunc) swig_varlink_repr, /* tp_repr */
45943 0, /* tp_as_number */
45944 0, /* tp_as_sequence */
45945 0, /* tp_as_mapping */
45946 0, /* tp_hash */
45947 0, /* tp_call */
45948 0, /* tp_str */
45949 0, /* tp_getattro */
45950 0, /* tp_setattro */
45951 0, /* tp_as_buffer */
45952 0, /* tp_flags */
45953 0, /* tp_doc */
45954 #if PY_VERSION_HEX >= 0x02000000
45955 0, /* tp_traverse */
45956 0, /* tp_clear */
45957 #endif
45958 #if PY_VERSION_HEX >= 0x02010000
45959 0, /* tp_richcompare */
45960 0, /* tp_weaklistoffset */
45961 #endif
45962 #if PY_VERSION_HEX >= 0x02020000
45963 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
45964 #endif
45965 #if PY_VERSION_HEX >= 0x02030000
45966 0, /* tp_del */
45967 #endif
45968 #ifdef COUNT_ALLOCS
45969 0,0,0,0 /* tp_alloc -> tp_next */
45970 #endif
45971 };
45972
45973 /* Create a variable linking object for use later */
45974 static PyObject *
45975 SWIG_Python_newvarlink(void) {
45976 swig_varlinkobject *result = 0;
45977 result = PyMem_NEW(swig_varlinkobject,1);
45978 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
45979 result->ob_type = &varlinktype;
45980 result->vars = 0;
45981 result->ob_refcnt = 0;
45982 Py_XINCREF((PyObject *) result);
45983 return ((PyObject*) result);
45984 }
45985
45986 static void
45987 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
45988 swig_varlinkobject *v;
45989 swig_globalvar *gv;
45990 v= (swig_varlinkobject *) p;
45991 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
45992 gv->name = (char *) malloc(strlen(name)+1);
45993 strcpy(gv->name,name);
45994 gv->get_attr = get_attr;
45995 gv->set_attr = set_attr;
45996 gv->next = v->vars;
45997 v->vars = gv;
45998 }
45999
46000 /* -----------------------------------------------------------------------------
46001 * constants/methods manipulation
46002 * ----------------------------------------------------------------------------- */
46003
46004 /* Install Constants */
46005 static void
46006 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46007 PyObject *obj = 0;
46008 size_t i;
46009 for (i = 0; constants[i].type; i++) {
46010 switch(constants[i].type) {
46011 case SWIG_PY_INT:
46012 obj = PyInt_FromLong(constants[i].lvalue);
46013 break;
46014 case SWIG_PY_FLOAT:
46015 obj = PyFloat_FromDouble(constants[i].dvalue);
46016 break;
46017 case SWIG_PY_STRING:
46018 if (constants[i].pvalue) {
46019 obj = PyString_FromString((char *) constants[i].pvalue);
46020 } else {
46021 Py_INCREF(Py_None);
46022 obj = Py_None;
46023 }
46024 break;
46025 case SWIG_PY_POINTER:
46026 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
46027 break;
46028 case SWIG_PY_BINARY:
46029 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
46030 break;
46031 default:
46032 obj = 0;
46033 break;
46034 }
46035 if (obj) {
46036 PyDict_SetItemString(d,constants[i].name,obj);
46037 Py_DECREF(obj);
46038 }
46039 }
46040 }
46041
46042 /* -----------------------------------------------------------------------------*/
46043 /* Fix SwigMethods to carry the callback ptrs when needed */
46044 /* -----------------------------------------------------------------------------*/
46045
46046 static void
46047 SWIG_Python_FixMethods(PyMethodDef *methods,
46048 swig_const_info *const_table,
46049 swig_type_info **types,
46050 swig_type_info **types_initial) {
46051 size_t i;
46052 for (i = 0; methods[i].ml_name; ++i) {
46053 char *c = methods[i].ml_doc;
46054 if (c && (c = strstr(c, "swig_ptr: "))) {
46055 int j;
46056 swig_const_info *ci = 0;
46057 char *name = c + 10;
46058 for (j = 0; const_table[j].type; j++) {
46059 if (strncmp(const_table[j].name, name,
46060 strlen(const_table[j].name)) == 0) {
46061 ci = &(const_table[j]);
46062 break;
46063 }
46064 }
46065 if (ci) {
46066 size_t shift = (ci->ptype) - types;
46067 swig_type_info *ty = types_initial[shift];
46068 size_t ldoc = (c - methods[i].ml_doc);
46069 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
46070 char *ndoc = (char*)malloc(ldoc + lptr + 10);
46071 char *buff = ndoc;
46072 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
46073 strncpy(buff, methods[i].ml_doc, ldoc);
46074 buff += ldoc;
46075 strncpy(buff, "swig_ptr: ", 10);
46076 buff += 10;
46077 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
46078 methods[i].ml_doc = ndoc;
46079 }
46080 }
46081 }
46082 }
46083
46084 /* -----------------------------------------------------------------------------*
46085 * Initialize type list
46086 * -----------------------------------------------------------------------------*/
46087
46088 #if PY_MAJOR_VERSION < 2
46089 /* PyModule_AddObject function was introduced in Python 2.0. The following function
46090 is copied out of Python/modsupport.c in python version 2.3.4 */
46091 static int
46092 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
46093 {
46094 PyObject *dict;
46095 if (!PyModule_Check(m)) {
46096 PyErr_SetString(PyExc_TypeError,
46097 "PyModule_AddObject() needs module as first arg");
46098 return -1;
46099 }
46100 if (!o) {
46101 PyErr_SetString(PyExc_TypeError,
46102 "PyModule_AddObject() needs non-NULL value");
46103 return -1;
46104 }
46105
46106 dict = PyModule_GetDict(m);
46107 if (dict == NULL) {
46108 /* Internal error -- modules must have a dict! */
46109 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
46110 PyModule_GetName(m));
46111 return -1;
46112 }
46113 if (PyDict_SetItemString(dict, name, o))
46114 return -1;
46115 Py_DECREF(o);
46116 return 0;
46117 }
46118 #endif
46119
46120 static swig_type_info **
46121 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
46122 static PyMethodDef swig_empty_runtime_method_table[] = {
46123 {
46124 NULL, NULL, 0, NULL
46125 }
46126 };/* Sentinel */
46127
46128 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
46129 swig_empty_runtime_method_table);
46130 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
46131 if (pointer && module) {
46132 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
46133 }
46134 return type_list_handle;
46135 }
46136
46137 static swig_type_info **
46138 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
46139 swig_type_info **type_pointer;
46140
46141 /* first check if module already created */
46142 type_pointer = SWIG_Python_GetTypeListHandle();
46143 if (type_pointer) {
46144 return type_pointer;
46145 } else {
46146 /* create a new module and variable */
46147 return SWIG_Python_SetTypeListHandle(type_list_handle);
46148 }
46149 }
46150
46151 #ifdef __cplusplus
46152 }
46153 #endif
46154
46155 /* -----------------------------------------------------------------------------*
46156 * Partial Init method
46157 * -----------------------------------------------------------------------------*/
46158
46159 #ifdef SWIG_LINK_RUNTIME
46160 #ifdef __cplusplus
46161 extern "C"
46162 #endif
46163 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
46164 #endif
46165
46166 #ifdef __cplusplus
46167 extern "C"
46168 #endif
46169 SWIGEXPORT(void) SWIG_init(void) {
46170 static PyObject *SWIG_globals = 0;
46171 static int typeinit = 0;
46172 PyObject *m, *d;
46173 int i;
46174 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
46175
46176 /* Fix SwigMethods to carry the callback ptrs when needed */
46177 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
46178
46179 m = Py_InitModule((char *) SWIG_name, SwigMethods);
46180 d = PyModule_GetDict(m);
46181
46182 if (!typeinit) {
46183 #ifdef SWIG_LINK_RUNTIME
46184 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
46185 #else
46186 # ifndef SWIG_STATIC_RUNTIME
46187 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
46188 # endif
46189 #endif
46190 for (i = 0; swig_types_initial[i]; i++) {
46191 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
46192 }
46193 typeinit = 1;
46194 }
46195 SWIG_InstallConstants(d,swig_const_table);
46196
46197
46198 #ifndef wxPyUSE_EXPORT
46199 // Make our API structure a CObject so other modules can import it
46200 // from this module.
46201 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
46202 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
46203 Py_XDECREF(cobj);
46204 #endif
46205
46206 {
46207 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
46208 }
46209 {
46210 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
46211 }
46212 {
46213 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
46214 }
46215 {
46216 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
46217 }
46218 {
46219 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
46220 }
46221 {
46222 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
46223 }
46224 {
46225 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
46226 }
46227 {
46228 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
46229 }
46230 {
46231 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
46232 }
46233 {
46234 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
46235 }
46236 {
46237 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
46238 }
46239 {
46240 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
46241 }
46242 {
46243 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
46244 }
46245 {
46246 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
46247 }
46248 {
46249 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
46250 }
46251 {
46252 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
46253 }
46254 {
46255 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
46256 }
46257 {
46258 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
46259 }
46260 {
46261 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
46262 }
46263 {
46264 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
46265 }
46266 {
46267 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
46268 }
46269 {
46270 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
46271 }
46272 {
46273 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
46274 }
46275 {
46276 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
46277 }
46278 {
46279 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
46280 }
46281 {
46282 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
46283 }
46284 {
46285 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
46286 }
46287 {
46288 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
46289 }
46290 {
46291 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
46292 }
46293 {
46294 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
46295 }
46296 {
46297 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
46298 }
46299 {
46300 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
46301 }
46302 {
46303 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
46304 }
46305 {
46306 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
46307 }
46308 {
46309 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
46310 }
46311 {
46312 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
46313 }
46314 {
46315 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
46316 }
46317 {
46318 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
46319 }
46320 {
46321 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
46322 }
46323 {
46324 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
46325 }
46326 {
46327 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
46328 }
46329 {
46330 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
46331 }
46332 {
46333 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
46334 }
46335 {
46336 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
46337 }
46338 {
46339 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
46340 }
46341 {
46342 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
46343 }
46344 {
46345 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
46346 }
46347 {
46348 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
46349 }
46350 {
46351 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
46352 }
46353 {
46354 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
46355 }
46356 {
46357 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
46358 }
46359 {
46360 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
46361 }
46362 {
46363 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
46364 }
46365 {
46366 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
46367 }
46368 {
46369 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
46370 }
46371 {
46372 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
46373 }
46374 {
46375 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
46376 }
46377 {
46378 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
46379 }
46380 {
46381 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
46382 }
46383 {
46384 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
46385 }
46386 {
46387 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
46388 }
46389 {
46390 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
46391 }
46392 {
46393 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
46394 }
46395 {
46396 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
46397 }
46398 {
46399 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
46400 }
46401 {
46402 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
46403 }
46404 {
46405 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
46406 }
46407 {
46408 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
46409 }
46410 {
46411 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
46412 }
46413 {
46414 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
46415 }
46416 {
46417 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
46418 }
46419 {
46420 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
46421 }
46422 {
46423 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
46424 }
46425 {
46426 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
46427 }
46428 {
46429 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
46430 }
46431 {
46432 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
46433 }
46434 {
46435 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
46436 }
46437 {
46438 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
46439 }
46440 {
46441 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
46442 }
46443 {
46444 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
46445 }
46446 {
46447 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
46448 }
46449 {
46450 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
46451 }
46452 {
46453 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
46454 }
46455 {
46456 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
46457 }
46458 {
46459 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
46460 }
46461 {
46462 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
46463 }
46464 {
46465 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
46466 }
46467 {
46468 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
46469 }
46470 {
46471 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
46472 }
46473 {
46474 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
46475 }
46476 {
46477 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
46478 }
46479 {
46480 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
46481 }
46482 {
46483 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
46484 }
46485 {
46486 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
46487 }
46488 {
46489 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
46490 }
46491 {
46492 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
46493 }
46494 {
46495 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
46496 }
46497 {
46498 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
46499 }
46500 {
46501 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
46502 }
46503 {
46504 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
46505 }
46506 {
46507 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
46508 }
46509 {
46510 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
46511 }
46512 {
46513 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
46514 }
46515 {
46516 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
46517 }
46518 {
46519 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
46520 }
46521 {
46522 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
46523 }
46524 {
46525 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
46526 }
46527 {
46528 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
46529 }
46530 {
46531 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
46532 }
46533 {
46534 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
46535 }
46536 {
46537 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
46538 }
46539 {
46540 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
46541 }
46542 {
46543 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
46544 }
46545 {
46546 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
46547 }
46548 {
46549 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
46550 }
46551 {
46552 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
46553 }
46554 {
46555 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
46556 }
46557 {
46558 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
46559 }
46560 {
46561 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
46562 }
46563 {
46564 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
46565 }
46566 {
46567 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
46568 }
46569 {
46570 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
46571 }
46572 {
46573 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
46574 }
46575 {
46576 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
46577 }
46578 {
46579 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
46580 }
46581 {
46582 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
46583 }
46584 {
46585 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
46586 }
46587 {
46588 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
46589 }
46590 {
46591 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
46592 }
46593 {
46594 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
46595 }
46596 {
46597 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
46598 }
46599 {
46600 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
46601 }
46602 {
46603 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
46604 }
46605 {
46606 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
46607 }
46608 {
46609 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
46610 }
46611 {
46612 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
46613 }
46614 {
46615 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
46616 }
46617 {
46618 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
46619 }
46620 {
46621 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
46622 }
46623 {
46624 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
46625 }
46626 {
46627 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
46628 }
46629 {
46630 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
46631 }
46632 {
46633 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
46634 }
46635 {
46636 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
46637 }
46638 {
46639 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
46640 }
46641 {
46642 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
46643 }
46644 {
46645 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
46646 }
46647 {
46648 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
46649 }
46650 {
46651 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
46652 }
46653 {
46654 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
46655 }
46656 {
46657 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
46658 }
46659 {
46660 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
46661 }
46662 {
46663 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
46664 }
46665 {
46666 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
46667 }
46668 {
46669 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
46670 }
46671 {
46672 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
46673 }
46674 {
46675 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
46676 }
46677 {
46678 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
46679 }
46680 {
46681 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
46682 }
46683 {
46684 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
46685 }
46686 {
46687 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
46688 }
46689 {
46690 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
46691 }
46692 {
46693 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
46694 }
46695 {
46696 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
46697 }
46698 {
46699 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
46700 }
46701 {
46702 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
46703 }
46704 {
46705 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
46706 }
46707 {
46708 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
46709 }
46710 {
46711 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
46712 }
46713 {
46714 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
46715 }
46716 {
46717 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
46718 }
46719 {
46720 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
46721 }
46722 {
46723 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
46724 }
46725 {
46726 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
46727 }
46728 {
46729 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
46730 }
46731 {
46732 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
46733 }
46734 {
46735 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
46736 }
46737 {
46738 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
46739 }
46740 {
46741 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
46742 }
46743 {
46744 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
46745 }
46746 {
46747 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
46748 }
46749 {
46750 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
46751 }
46752 {
46753 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
46754 }
46755 {
46756 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
46757 }
46758 {
46759 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
46760 }
46761 {
46762 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
46763 }
46764 {
46765 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
46766 }
46767 {
46768 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
46769 }
46770 {
46771 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
46772 }
46773 {
46774 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
46775 }
46776 {
46777 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
46778 }
46779 {
46780 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
46781 }
46782 {
46783 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
46784 }
46785 {
46786 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
46787 }
46788 {
46789 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
46790 }
46791 {
46792 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
46793 }
46794 {
46795 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
46796 }
46797 {
46798 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
46799 }
46800 {
46801 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
46802 }
46803 {
46804 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
46805 }
46806 {
46807 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
46808 }
46809 {
46810 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
46811 }
46812 {
46813 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
46814 }
46815 {
46816 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
46817 }
46818 {
46819 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
46820 }
46821 {
46822 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
46823 }
46824 {
46825 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
46826 }
46827 {
46828 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
46829 }
46830 {
46831 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
46832 }
46833 {
46834 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
46835 }
46836 {
46837 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
46838 }
46839 {
46840 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
46841 }
46842 {
46843 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
46844 }
46845 {
46846 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
46847 }
46848 {
46849 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
46850 }
46851 {
46852 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
46853 }
46854 {
46855 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
46856 }
46857 {
46858 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
46859 }
46860 {
46861 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
46862 }
46863 {
46864 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
46865 }
46866 {
46867 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
46868 }
46869 {
46870 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
46871 }
46872 {
46873 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
46874 }
46875 {
46876 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
46877 }
46878 {
46879 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
46880 }
46881 {
46882 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
46883 }
46884 {
46885 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
46886 }
46887 {
46888 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
46889 }
46890 {
46891 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
46892 }
46893 {
46894 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
46895 }
46896 {
46897 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
46898 }
46899 {
46900 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
46901 }
46902 {
46903 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
46904 }
46905 {
46906 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
46907 }
46908 {
46909 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
46910 }
46911 {
46912 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
46913 }
46914 {
46915 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
46916 }
46917 {
46918 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
46919 }
46920 {
46921 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
46922 }
46923 {
46924 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
46925 }
46926 {
46927 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
46928 }
46929 {
46930 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
46931 }
46932 {
46933 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
46934 }
46935 {
46936 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
46937 }
46938 {
46939 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
46940 }
46941 {
46942 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
46943 }
46944 {
46945 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
46946 }
46947 {
46948 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
46949 }
46950 {
46951 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
46952 }
46953 {
46954 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
46955 }
46956 {
46957 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
46958 }
46959 {
46960 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
46961 }
46962 {
46963 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
46964 }
46965 {
46966 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
46967 }
46968 {
46969 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
46970 }
46971 {
46972 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
46973 }
46974 {
46975 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
46976 }
46977 {
46978 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
46979 }
46980 {
46981 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
46982 }
46983 {
46984 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
46985 }
46986 {
46987 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
46988 }
46989 {
46990 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
46991 }
46992 {
46993 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
46994 }
46995 {
46996 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
46997 }
46998 {
46999 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47000 }
47001 {
47002 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47003 }
47004 {
47005 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47006 }
47007 {
47008 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47009 }
47010 {
47011 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47012 }
47013 {
47014 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47015 }
47016 {
47017 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
47018 }
47019 {
47020 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
47021 }
47022 {
47023 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
47024 }
47025 {
47026 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
47027 }
47028 {
47029 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
47030 }
47031 {
47032 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
47033 }
47034 {
47035 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
47036 }
47037 {
47038 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
47039 }
47040 {
47041 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
47042 }
47043 {
47044 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
47045 }
47046 {
47047 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
47048 }
47049 {
47050 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
47051 }
47052 {
47053 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
47054 }
47055 {
47056 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
47057 }
47058 {
47059 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
47060 }
47061 {
47062 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
47063 }
47064 {
47065 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
47066 }
47067 {
47068 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
47069 }
47070 {
47071 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
47072 }
47073 {
47074 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
47075 }
47076 {
47077 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
47078 }
47079 {
47080 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
47081 }
47082 {
47083 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
47084 }
47085 {
47086 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
47087 }
47088 {
47089 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
47090 }
47091 {
47092 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
47093 }
47094 {
47095 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
47096 }
47097 {
47098 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
47099 }
47100 {
47101 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
47102 }
47103 {
47104 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
47105 }
47106 {
47107 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
47108 }
47109 {
47110 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
47111 }
47112 {
47113 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
47114 }
47115 {
47116 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
47117 }
47118 {
47119 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
47120 }
47121 {
47122 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
47123 }
47124 {
47125 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
47126 }
47127 {
47128 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
47129 }
47130 {
47131 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
47132 }
47133 {
47134 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
47135 }
47136 {
47137 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
47138 }
47139 {
47140 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
47141 }
47142 {
47143 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
47144 }
47145 {
47146 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
47147 }
47148 {
47149 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
47150 }
47151 {
47152 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
47153 }
47154 {
47155 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
47156 }
47157 {
47158 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
47159 }
47160 {
47161 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
47162 }
47163 {
47164 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
47165 }
47166 {
47167 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
47168 }
47169 {
47170 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
47171 }
47172 {
47173 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
47174 }
47175 {
47176 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
47177 }
47178 {
47179 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
47180 }
47181 {
47182 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
47183 }
47184 {
47185 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
47186 }
47187 {
47188 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
47189 }
47190 {
47191 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
47192 }
47193 {
47194 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
47195 }
47196 {
47197 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
47198 }
47199 {
47200 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
47201 }
47202 {
47203 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
47204 }
47205 {
47206 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
47207 }
47208 {
47209 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
47210 }
47211 {
47212 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
47213 }
47214 {
47215 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
47216 }
47217 {
47218 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
47219 }
47220 {
47221 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
47222 }
47223 {
47224 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
47225 }
47226 {
47227 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
47228 }
47229 {
47230 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
47231 }
47232 {
47233 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
47234 }
47235 {
47236 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
47237 }
47238 {
47239 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
47240 }
47241 {
47242 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
47243 }
47244 {
47245 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
47246 }
47247 {
47248 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
47249 }
47250 {
47251 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
47252 }
47253 {
47254 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
47255 }
47256 {
47257 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
47258 }
47259 {
47260 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
47261 }
47262 {
47263 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
47264 }
47265 {
47266 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
47267 }
47268 {
47269 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
47270 }
47271 {
47272 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
47273 }
47274 {
47275 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
47276 }
47277 {
47278 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
47279 }
47280 {
47281 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
47282 }
47283 {
47284 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
47285 }
47286 {
47287 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
47288 }
47289 {
47290 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
47291 }
47292 {
47293 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
47294 }
47295 {
47296 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
47297 }
47298 {
47299 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
47300 }
47301 {
47302 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
47303 }
47304 {
47305 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
47306 }
47307 {
47308 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
47309 }
47310 {
47311 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
47312 }
47313 {
47314 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
47315 }
47316 {
47317 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
47318 }
47319 {
47320 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
47321 }
47322 {
47323 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
47324 }
47325 {
47326 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
47327 }
47328 {
47329 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
47330 }
47331 {
47332 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
47333 }
47334 {
47335 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
47336 }
47337 {
47338 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
47339 }
47340 {
47341 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
47342 }
47343 {
47344 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
47345 }
47346 {
47347 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
47348 }
47349 {
47350 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
47351 }
47352 {
47353 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
47354 }
47355 {
47356 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
47357 }
47358 {
47359 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
47360 }
47361 {
47362 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
47363 }
47364 {
47365 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
47366 }
47367 {
47368 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
47369 }
47370 {
47371 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
47372 }
47373 {
47374 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
47375 }
47376 {
47377 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
47378 }
47379 {
47380 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
47381 }
47382 {
47383 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
47384 }
47385 {
47386 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
47387 }
47388 {
47389 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
47390 }
47391 {
47392 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
47393 }
47394 {
47395 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
47396 }
47397 {
47398 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
47399 }
47400 {
47401 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
47402 }
47403 {
47404 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
47405 }
47406 {
47407 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
47408 }
47409 {
47410 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
47411 }
47412 {
47413 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
47414 }
47415 {
47416 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
47417 }
47418 {
47419 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
47420 }
47421 {
47422 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
47423 }
47424 {
47425 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
47426 }
47427 {
47428 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
47429 }
47430 {
47431 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
47432 }
47433 {
47434 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
47435 }
47436 {
47437 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
47438 }
47439 {
47440 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
47441 }
47442 {
47443 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
47444 }
47445 {
47446 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
47447 }
47448 {
47449 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
47450 }
47451 {
47452 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
47453 }
47454 {
47455 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
47456 }
47457 {
47458 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
47459 }
47460 {
47461 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
47462 }
47463 {
47464 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
47465 }
47466 {
47467 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
47468 }
47469 {
47470 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
47471 }
47472 {
47473 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
47474 }
47475 {
47476 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
47477 }
47478 {
47479 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
47480 }
47481 {
47482 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
47483 }
47484 {
47485 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
47486 }
47487 {
47488 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
47489 }
47490 {
47491 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
47492 }
47493 {
47494 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
47495 }
47496 {
47497 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
47498 }
47499 {
47500 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
47501 }
47502 {
47503 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
47504 }
47505 {
47506 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
47507 }
47508 {
47509 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
47510 }
47511 {
47512 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
47513 }
47514 {
47515 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
47516 }
47517 {
47518 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
47519 }
47520 {
47521 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
47522 }
47523 {
47524 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
47525 }
47526 {
47527 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
47528 }
47529 {
47530 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
47531 }
47532 {
47533 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
47534 }
47535 {
47536 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
47537 }
47538 {
47539 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
47540 }
47541 {
47542 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
47543 }
47544 {
47545 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
47546 }
47547 {
47548 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
47549 }
47550 {
47551 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
47552 }
47553 {
47554 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
47555 }
47556 {
47557 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
47558 }
47559 {
47560 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
47561 }
47562 {
47563 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
47564 }
47565 {
47566 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
47567 }
47568 {
47569 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
47570 }
47571 {
47572 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
47573 }
47574 {
47575 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
47576 }
47577 {
47578 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
47579 }
47580 {
47581 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
47582 }
47583 {
47584 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
47585 }
47586 {
47587 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
47588 }
47589 {
47590 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
47591 }
47592 {
47593 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
47594 }
47595 {
47596 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
47597 }
47598 {
47599 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
47600 }
47601 {
47602 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
47603 }
47604 {
47605 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
47606 }
47607 {
47608 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
47609 }
47610 {
47611 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
47612 }
47613 {
47614 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
47615 }
47616 {
47617 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
47618 }
47619 {
47620 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
47621 }
47622 {
47623 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
47624 }
47625 {
47626 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
47627 }
47628 {
47629 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
47630 }
47631 {
47632 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
47633 }
47634 {
47635 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
47636 }
47637 {
47638 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
47639 }
47640 {
47641 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
47642 }
47643 {
47644 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
47645 }
47646 {
47647 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
47648 }
47649 {
47650 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
47651 }
47652 {
47653 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
47654 }
47655 {
47656 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
47657 }
47658 {
47659 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
47660 }
47661 {
47662 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
47663 }
47664 {
47665 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
47666 }
47667 {
47668 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
47669 }
47670 {
47671 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
47672 }
47673 {
47674 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
47675 }
47676 {
47677 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
47678 }
47679 {
47680 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
47681 }
47682 {
47683 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
47684 }
47685 {
47686 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
47687 }
47688 {
47689 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
47690 }
47691 {
47692 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
47693 }
47694 {
47695 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
47696 }
47697 {
47698 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
47699 }
47700 {
47701 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
47702 }
47703 {
47704 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
47705 }
47706 {
47707 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
47708 }
47709 {
47710 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
47711 }
47712 {
47713 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
47714 }
47715 {
47716 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
47717 }
47718 {
47719 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
47720 }
47721 {
47722 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
47723 }
47724 {
47725 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
47726 }
47727 {
47728 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
47729 }
47730 {
47731 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
47732 }
47733 {
47734 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
47735 }
47736 {
47737 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
47738 }
47739 {
47740 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
47741 }
47742 {
47743 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
47744 }
47745 {
47746 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
47747 }
47748 {
47749 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
47750 }
47751 {
47752 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
47753 }
47754 {
47755 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
47756 }
47757 {
47758 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
47759 }
47760 {
47761 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
47762 }
47763 {
47764 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
47765 }
47766 {
47767 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
47768 }
47769 {
47770 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
47771 }
47772 {
47773 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
47774 }
47775 {
47776 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
47777 }
47778 {
47779 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
47780 }
47781 {
47782 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
47783 }
47784 {
47785 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
47786 }
47787 {
47788 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
47789 }
47790 {
47791 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
47792 }
47793 {
47794 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
47795 }
47796 {
47797 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
47798 }
47799 {
47800 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
47801 }
47802 {
47803 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
47804 }
47805 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
47806 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
47807 {
47808 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
47809 }
47810 {
47811 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
47812 }
47813 {
47814 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
47815 }
47816 {
47817 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
47818 }
47819 {
47820 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
47821 }
47822 {
47823 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
47824 }
47825 {
47826 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
47827 }
47828 {
47829 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
47830 }
47831 {
47832 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
47833 }
47834 {
47835 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
47836 }
47837 {
47838 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
47839 }
47840 {
47841 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
47842 }
47843 {
47844 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
47845 }
47846 {
47847 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
47848 }
47849 {
47850 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
47851 }
47852 {
47853 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
47854 }
47855 {
47856 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
47857 }
47858 {
47859 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
47860 }
47861 {
47862 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
47863 }
47864 {
47865 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
47866 }
47867 {
47868 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
47869 }
47870 {
47871 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
47872 }
47873 {
47874 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
47875 }
47876 {
47877 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
47878 }
47879 {
47880 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
47881 }
47882 {
47883 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
47884 }
47885 {
47886 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
47887 }
47888 {
47889 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
47890 }
47891 {
47892 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
47893 }
47894 {
47895 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
47896 }
47897 {
47898 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
47899 }
47900 {
47901 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
47902 }
47903 {
47904 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
47905 }
47906 {
47907 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
47908 }
47909 {
47910 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
47911 }
47912 {
47913 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
47914 }
47915 {
47916 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
47917 }
47918 {
47919 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
47920 }
47921 {
47922 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
47923 }
47924 {
47925 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
47926 }
47927 {
47928 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
47929 }
47930 {
47931 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
47932 }
47933 {
47934 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
47935 }
47936 {
47937 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
47938 }
47939 {
47940 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
47941 }
47942 {
47943 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
47944 }
47945 {
47946 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
47947 }
47948 {
47949 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
47950 }
47951 {
47952 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
47953 }
47954 {
47955 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
47956 }
47957 {
47958 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
47959 }
47960 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
47961 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
47962 {
47963 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
47970 }
47971
47972 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
47973
47974
47975 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
47976
47977 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
47978 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
47979 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
47980 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
47981 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
47982 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
47983 {
47984 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
48027 }
48028 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
48029 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
48030 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
48031 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
48032 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
48033 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
48034 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
48035 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
48036 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
48037 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
48038 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
48039 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
48040 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
48041 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
48042 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
48043 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
48044 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
48045 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
48046 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
48047 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
48048 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
48049 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
48050 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
48051 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
48052 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
48053 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
48054 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
48055 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
48056 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
48057 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
48058 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
48059 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
48060 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
48061 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
48062 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
48063 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
48064 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
48065 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
48066 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
48067 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
48068 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
48069 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
48070 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
48071 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
48072 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
48073 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
48074 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
48075 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
48076 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
48077 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
48078 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
48079 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
48080 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
48081 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
48082 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
48083 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
48084 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
48085 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
48086 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
48087 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
48088 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
48089 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
48090 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
48091 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
48092 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
48093 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
48094 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
48095 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
48096 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
48097 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
48098 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
48099 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
48100 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
48101 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
48102 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
48103 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
48104 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
48105 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
48106 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
48107 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
48108 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
48109 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
48110 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
48111 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
48112 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
48113 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
48114 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
48115 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
48116 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
48117 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
48118 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
48119 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
48120 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
48121 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
48122 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
48123 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
48124 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
48125 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
48126 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
48127 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
48128 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
48129 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
48130 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
48131 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
48132 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
48133 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
48134 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
48135 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
48136 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
48137 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
48138 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
48139 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
48140 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
48141 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
48142 {
48143 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
48195 }
48196 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
48197 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
48198 {
48199 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
48200 }
48201 {
48202 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
48203 }
48204 {
48205 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
48206 }
48207 {
48208 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
48209 }
48210 {
48211 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
48212 }
48213 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
48214 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
48215 {
48216 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
48217 }
48218 {
48219 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
48220 }
48221 {
48222 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
48223 }
48224 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
48225 {
48226 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
48227 }
48228 {
48229 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
48230 }
48231 {
48232 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
48233 }
48234 {
48235 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
48236 }
48237 {
48238 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
48239 }
48240 {
48241 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
48242 }
48243 {
48244 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
48245 }
48246 {
48247 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
48248 }
48249 {
48250 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
48251 }
48252 {
48253 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
48254 }
48255 {
48256 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
48257 }
48258 {
48259 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
48260 }
48261 {
48262 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
48263 }
48264 {
48265 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
48266 }
48267 {
48268 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
48269 }
48270 {
48271 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
48272 }
48273 {
48274 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
48275 }
48276 {
48277 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
48278 }
48279 {
48280 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
48281 }
48282
48283 // Initialize threading, some globals and such
48284 __wxPyPreStart(d);
48285
48286
48287 // Although these are defined in __version__ they need to be here too so
48288 // that an assert can be done to ensure that the wxPython and the wxWindows
48289 // versions match.
48290 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
48291 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
48292 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
48293
48294 }
48295
wxWidgets (Impactor)